[basic.scope.pdecl] - C++20 → C++23

Files changed (1) hide show

tmp/tmpzg3vu1io/{from.md → to.md} +49 -66

tmp/tmpzg3vu1io/{from.md → to.md} RENAMED Viewed

@@ -1,10 +1,9 @@
 ### Point of declaration <a id="basic.scope.pdecl">[[basic.scope.pdecl]]</a>
-The *point of declaration* for a name is immediately after its complete
-declarator [[dcl.decl]] and before its *initializer* (if any), except as
-noted below.
 [*Example 1*:
 ``` cpp
 unsigned char x = 12;
@@ -17,12 +16,12 @@ because the initializer accesses the second `x` outside its lifetime
 — *end example*]
 [*Note 1*:
-A name from an outer scope remains visible up to the point of
-declaration of the name that hides it.
 [*Example 2*:
 ``` cpp
 const int  i = 2;
@@ -33,25 +32,21 @@ declares a block-scope array of two integers.
 — *end example*]
 — *end note*]
-The point of declaration for a class or class template first declared by
-a *class-specifier* is immediately after the *identifier* or
-*simple-template-id* (if any) in its *class-head* [[class.pre]]. The
-point of declaration for an enumeration is immediately after the
-*identifier* (if any) in either its *enum-specifier* [[dcl.enum]] or its
-first *opaque-enum-declaration* [[dcl.enum]], whichever comes first. The
-point of declaration of an alias or alias template immediately follows
-the *defining-type-id* to which the alias refers.
-The point of declaration of a *using-declarator* that does not name a
-constructor is immediately after the *using-declarator*
-[[namespace.udecl]].
-The point of declaration for an enumerator is immediately after its
-*enumerator-definition*.
 [*Example 3*:
 ``` cpp
 const int x = 12;
@@ -61,88 +56,76 @@ const int x = 12;
 Here, the enumerator `x` is initialized with the value of the constant
 `x`, namely 12.
 — *end example*]
-After the point of declaration of a class member, the member name can be
-looked up in the scope of its class.
 [*Note 2*:
-This is true even if the class is an incomplete class. For example,
 ``` cpp
 struct X {
   enum E { z = 16 };
   int b[X::z];          // OK
 };
 ```
 — *end note*]
-The point of declaration of a class first declared in an
-*elaborated-type-specifier* is as follows:
-- for a declaration of the form
-  ``` bnf
-  class-key attribute-specifier-seqₒₚₜ identifier ';'
-  ```
-  the *identifier* is declared to be a *class-name* in the scope that
-  contains the declaration, otherwise
-- for an *elaborated-type-specifier* of the form
-  ``` bnf
-  class-key identifier
-  ```
-  if the *elaborated-type-specifier* is used in the *decl-specifier-seq*
-  or *parameter-declaration-clause* of a function defined in namespace
-  scope, the *identifier* is declared as a *class-name* in the namespace
-  that contains the declaration; otherwise, except as a friend
-  declaration, the *identifier* is declared in the smallest namespace or
-  block scope that contains the declaration.
-  \[*Note 3*: These rules also apply within templates. — *end note*]
-  \[*Note 4*: Other forms of *elaborated-type-specifier* do not declare
-  a new name, and therefore must refer to an existing *type-name*. See
-  [[basic.lookup.elab]] and  [[dcl.type.elab]]. — *end note*]
-The point of declaration for an injected-class-name [[class.pre]] is
 immediately following the opening brace of the class definition.
-The point of declaration for a function-local predefined variable
-[[dcl.fct.def.general]] is immediately before the *function-body* of a
-function definition.
-The point of declaration of a structured binding [[dcl.struct.bind]] is
-immediately after the *identifier-list* of the structured binding
 declaration.
-The point of declaration for the variable or the structured bindings
-declared in the *for-range-declaration* of a range-based `for` statement
 [[stmt.ranged]] is immediately after the *for-range-initializer*.
-The point of declaration for a template parameter is immediately after
-its complete *template-parameter*.
-[*Example 4*:
 ``` cpp
 typedef unsigned char T;
 template<class T
-  = T               // lookup finds the typedef name of unsigned char
   , T               // lookup finds the template parameter
     N = 0> struct A { };
 ```
 — *end example*]
-[*Note 5*: Friend declarations refer to functions or classes that are
-members of the nearest enclosing namespace, but they do not introduce
-new names into that namespace [[namespace.memdef]]. Function
-declarations at block scope and variable declarations with the `extern`
-specifier at block scope refer to declarations that are members of an
-enclosing namespace, but they do not introduce new names into that
-scope. — *end note*]
 [*Note 6*: For point of instantiation of a template, see
 [[temp.point]]. — *end note*]

 ### Point of declaration <a id="basic.scope.pdecl">[[basic.scope.pdecl]]</a>
+The *locus* of a declaration [[basic.pre]] that is a declarator is
+immediately after the complete declarator [[dcl.decl]].
 [*Example 1*:
 ``` cpp
 unsigned char x = 12;
 — *end example*]
 [*Note 1*:
+A name from an outer scope remains visible up to the locus of the
+declaration that hides it.
 [*Example 2*:
 ``` cpp
 const int  i = 2;
 — *end example*]
 — *end note*]
+The locus of a *class-specifier* is immediately after the *identifier*
+or *simple-template-id* (if any) in its *class-head* [[class.pre]]. The
+locus of an *enum-specifier* is immediately after its *enum-head*; the
+locus of an *opaque-enum-declaration* is immediately after it
+[[dcl.enum]]. The locus of an *alias-declaration* is immediately after
+it.
+The locus of a *using-declarator* that does not name a constructor is
+immediately after the *using-declarator* [[namespace.udecl]].
+The locus of an *enumerator-definition* is immediately after it.
 [*Example 3*:
 ``` cpp
 const int x = 12;
 Here, the enumerator `x` is initialized with the value of the constant
 `x`, namely 12.
 — *end example*]
 [*Note 2*:
+After the declaration of a class member, the member name can be found in
+the scope of its class even if the class is an incomplete class.
+[*Example 4*:
 ``` cpp
 struct X {
   enum E { z = 16 };
   int b[X::z];          // OK
 };
 ```
+— *end example*]
 — *end note*]
+The locus of an *elaborated-type-specifier* that is a declaration
+[[dcl.type.elab]] is immediately after it.
+The locus of an injected-class-name declaration [[class.pre]] is
 immediately following the opening brace of the class definition.
+The locus of the implicit declaration of a function-local predefined
+variable [[dcl.fct.def.general]] is immediately before the
+*function-body* of its function’s definition.
+The locus of the declaration of a structured binding [[dcl.struct.bind]]
+is immediately after the *identifier-list* of the structured binding
 declaration.
+The locus of a *for-range-declaration* of a range-based `for` statement
 [[stmt.ranged]] is immediately after the *for-range-initializer*.
+The locus of a *template-parameter* is immediately after it.
+[*Example 5*:
 ``` cpp
 typedef unsigned char T;
 template<class T
+  = T               // lookup finds the typedef-name
   , T               // lookup finds the template parameter
     N = 0> struct A { };
 ```
 — *end example*]
+The locus of a *concept-definition* is immediately after its
+concept-name [[temp.concept]].
+[*Note 3*: The *constraint-expression* cannot use the
+*concept-name*. — *end note*]
+The locus of a *namespace-definition* with an *identifier* is
+immediately after the *identifier*.
+[*Note 4*: An identifier is invented for an
+*unnamed-namespace-definition* [[namespace.unnamed]]. — *end note*]
+[*Note 5*: Friend declarations can introduce functions or classes that
+belong to the nearest enclosing namespace or block scope, but they do
+not bind names anywhere [[class.friend]]. Function declarations at block
+scope and variable declarations with the `extern` specifier at block
+scope declare entities that belong to the nearest enclosing namespace,
+but they do not bind names in it. — *end note*]
 [*Note 6*: For point of instantiation of a template, see
 [[temp.point]]. — *end note*]

Diff to HTML by rtfpessoa