dcl.dcl first part

Author: jensmaurer

source/declarations.tex

@@ -126,11 +126,8 @@
 \pnum
 \indextext{declaration}%
 \indextext{scope}%
-A declaration occurs in a scope\iref{basic.scope}; the scope rules are
-summarized in~\ref{basic.lookup}. A declaration that declares a function
-or defines a class, namespace, template, or function also has one or
-more scopes nested within it. These nested scopes, in turn, can have
-declarations nested within them. Unless otherwise stated, utterances in
+Certain declarations contain one or more scopes\iref{basic.scope.scope}.
+Unless otherwise stated, utterances in
 \ref{dcl.dcl} about components in, of, or contained by a
 declaration or subcomponent thereof refer only to those components of
 the declaration that are \emph{not} nested within scopes nested within
@@ -141,19 +138,18 @@
 \indextext{declarator}%
 In a \grammarterm{simple-declaration}, the optional
 \grammarterm{init-declarator-list} can be omitted only when declaring a
-class\iref{class} or enumeration\iref{dcl.enum}, that is,
+class\iref{class.pre} or enumeration\iref{dcl.enum}, that is,
 when the \grammarterm{decl-specifier-seq} contains either a
 \grammarterm{class-specifier}, an \grammarterm{elaborated-type-specifier} with
 a \grammarterm{class-key}\iref{class.name}, or an
 \grammarterm{enum-specifier}. In these cases and whenever a
 \grammarterm{class-specifier} or \grammarterm{enum-specifier} is present in
 the \grammarterm{decl-specifier-seq}, the identifiers in these specifiers
-are among the names being declared by the declaration (as
+are also declared (as
 \grammarterm{class-name}{s}, \grammarterm{enum-name}{s}, or
 \grammarterm{enumerator}{s}, depending on the syntax). In such cases,
-the \grammarterm{decl-specifier-seq} shall introduce one or more names into
-the program, or shall redeclare a name introduced by a previous
-declaration.
+the \grammarterm{decl-specifier-seq} shall (re)introduce one or more names into
+the program.
 \begin{example}
 \begin{codeblock}
 enum { };           // error
@@ -201,25 +197,30 @@
 \grammarterm{assignment-expression} is of array or non-union class type.
 
 \pnum
-Each \grammarterm{init-declarator} in the \grammarterm{init-declarator-list}
-contains exactly one \grammarterm{declarator-id}, which is the name
-declared by that \grammarterm{init-declarator} and hence one of the names
-declared by the declaration. The
-\grammarterm{defining-type-specifier}{s}\iref{dcl.type} in the
-\grammarterm{decl-specifier-seq} and the recursive \grammarterm{declarator}
-structure of the \grammarterm{init-declarator} describe a
-type\iref{dcl.meaning}, which is then associated with the name being
-declared by the \grammarterm{init-declarator}.
+If a \grammarterm{declarator-id} is a name, the
+\grammarterm{init-declarator} and (hence) the declaration introduce that name.
+\begin{note}
+Otherwise, the \grammarterm{declarator-id} is
+a \grammarterm{qualified-id} or
+names a destructor or
+its \grammarterm{unqualified-id} is a \grammarterm{template-id} and
+no name is introduced.
+\end{note}
+The \grammarterm{defining-type-specifier}{s}\iref{dcl.type} in
+the \grammarterm{decl-specifier-seq} and
+the recursive \grammarterm{declarator} structure
+describe a type\iref{dcl.meaning},
+which is then associated with the \grammarterm{declarator-id}.
 
 \pnum
 If the \grammarterm{decl-specifier-seq} contains the \tcode{typedef}
-specifier, the declaration is called a \defnx{typedef declaration}{declaration!typedef} and the name
-of each \grammarterm{init-declarator}
-is declared to be a \grammarterm{typedef-name}, synonymous with its
+specifier, the declaration is called a \defnx{typedef declaration}{declaration!typedef},
+each \grammarterm{declarator-id} shall be an \grammarterm{identifier}
+and is declared to be a \grammarterm{typedef-name}, synonymous with its
 associated type\iref{dcl.typedef}. If the
 \grammarterm{decl-specifier-seq} contains no \tcode{typedef} specifier, the
 declaration is called a \defnx{function declaration}{declaration!function} if
-the type associated with the name is a function type\iref{dcl.fct} and
+the type associated with a \grammarterm{declarator-id} is a function type\iref{dcl.fct} and
 an \defnx{object declaration}{declaration!object} otherwise.
 
 \pnum
@@ -354,10 +355,7 @@
 \tcode{typedef} specifier in the same \grammarterm{decl-specifier-seq} and
 the \grammarterm{init-declarator-list} or \grammarterm{member-declarator-list}
 of the declaration shall not be
-empty (except for an anonymous union declared in a named namespace or in the
-global namespace, which shall be declared
-\indextext{specifier!\idxcode{static}}%
-\tcode{static}\iref{class.union.anon}). The
+empty (except for an anonymous union declared in a namespace scope\iref{class.union.anon}). The
 \grammarterm{storage-class-specifier} applies to the name declared by each
 \grammarterm{init-declarator} in the list and not to any names declared by
 other specifiers.
@@ -421,10 +419,11 @@
 \end{note}
 
 \pnum
-The linkages implied by successive declarations for a given entity shall
-agree. That is, within a given scope, each declaration declaring the
-same variable name or the same overloading of a function name shall imply
-the same linkage.
+All declarations for a given entity shall give its name the same linkage.
+\begin{note}
+The linkage given by some declarations is affected by previous declarations.
+Overloads are distinct entities.
+\end{note}
 \begin{example}
 \begin{codeblock}
 static char* f();               // \tcode{f()} has internal linkage
@@ -599,7 +598,7 @@
 \pnum
 A \grammarterm{typedef-name} can also be introduced by an
 \grammarterm{alias-declaration}. The \grammarterm{identifier} following the
-\tcode{using} keyword becomes a \grammarterm{typedef-name}
+\tcode{using} keyword is not looked up; it becomes a \grammarterm{typedef-name}
 and the optional \grammarterm{attribute-specifier-seq} following the
 \grammarterm{identifier} appertains to that \grammarterm{typedef-name}.
 Such a \grammarterm{typedef-name} has the same
@@ -618,75 +617,6 @@
 a class or enumeration if the \grammarterm{alias-declaration}
 is the \grammarterm{declaration} of a \grammarterm{template-declaration}.
 
-\pnum
-\indextext{redefinition!\idxcode{typedef}}%
-In a given non-class scope, a \tcode{typedef} specifier can be used to
-redeclare the name of any type declared in that scope to refer to the
-type to which it already refers.
-\begin{example}
-\begin{codeblock}
-typedef struct s { @\commentellip@ } s;
-typedef int I;
-typedef int I;
-typedef I I;
-\end{codeblock}
-\end{example}
-
-\pnum
-In a given class scope, a \tcode{typedef} specifier can be used to
-redeclare any \grammarterm{class-name} declared in that scope that is not
-also a \grammarterm{typedef-name} to refer to the type to which it already
-refers.
-\begin{example}
-\begin{codeblock}
-struct S {
-  typedef struct A { } A;       // OK
-  typedef struct B B;           // OK
-  typedef A A;                  // error
-};
-\end{codeblock}
-\end{example}
-
-\pnum
-If a \tcode{typedef} specifier is used to redeclare in a given scope an
-entity that can be referenced using an \grammarterm{elaborated-type-specifier},
-the entity can continue to be referenced by an
-\grammarterm{elaborated-type-specifier} or as an enumeration or class name
-in an enumeration or class definition respectively.
-\begin{example}
-\begin{codeblock}
-struct S;
-typedef struct S S;
-int main() {
-  struct S* p;                  // OK
-}
-struct S { };                   // OK
-\end{codeblock}
-\end{example}
-
-\pnum
-In a given scope, a \tcode{typedef} specifier shall not be used to
-redeclare the name of any type declared in that scope to refer to a
-different type.
-\begin{example}
-\begin{codeblock}
-class complex { @\commentellip@ };
-typedef int complex;            // error: redefinition
-\end{codeblock}
-\end{example}
-
-\pnum
-Similarly, in a given scope, a class or enumeration shall not be
-declared with the same name as a \grammarterm{typedef-name} that is
-declared in that scope and refers to a type other than the class or
-enumeration itself.
-\begin{example}
-\begin{codeblock}
-typedef int complex;
-class complex { @\commentellip@ };    // error: redefinition
-\end{codeblock}
-\end{example}
-
 \pnum
 \indextext{class name!\idxcode{typedef}}%
 A \grammarterm{simple-template-id} is only a \grammarterm{typedef-name}
@@ -1097,13 +1027,11 @@
 \begin{note}
 An inline function or variable
 with external or module linkage
-has the same address in all translation units.
-A \tcode{static} local variable in an inline
-function with external or module linkage
-always refers to the same object.
-A type defined within the body of an inline
-function with external or module linkage is the
-same type in every translation unit.
+can be defined in multiple translation units\iref{basic.def.odr},
+but is one entity with one address.
+A type or \tcode{static} variable
+defined in the body of such a function
+is therefore a single entity.
 \end{note}
 
 \pnum