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

Files changed (1) hide show

tmp/tmp5n_g6vyg/{from.md → to.md} +342 -419

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

@@ -1,89 +1,206 @@
 ## Scope <a id="basic.scope">[[basic.scope]]</a>
-### Declarative regions and scopes <a id="basic.scope.declarative">[[basic.scope.declarative]]</a>
-Every name is introduced in some portion of program text called a
-*declarative region*, which is the largest part of the program in which
-that name is valid, that is, in which that name may be used as an
-unqualified name to refer to the same entity. In general, each
-particular name is valid only within some possibly discontiguous portion
-of program text called its *scope*. To determine the scope of a
-declaration, it is sometimes convenient to refer to the *potential
-scope* of a declaration. The scope of a declaration is the same as its
-potential scope unless the potential scope contains another declaration
-of the same name. In that case, the potential scope of the declaration
-in the inner (contained) declarative region is excluded from the scope
-of the declaration in the outer (containing) declarative region.
 [*Example 1*:
-In
 ``` cpp
-int j = 24;
-int main() {
-  int i = j, j;
-  j = 42;
 }
 ```
-the identifier `j` is declared twice as a name (and used twice). The
-declarative region of the first `j` includes the entire example. The
-potential scope of the first `j` begins immediately after that `j` and
-extends to the end of the program, but its (actual) scope excludes the
-text between the `,` and the `}`. The declarative region of the second
-declaration of `j` (the `j` immediately before the semicolon) includes
-all the text between `{` and `}`, but its potential scope excludes the
-declaration of `i`. The scope of the second declaration of `j` is the
-same as its potential scope.
 — *end example*]
-The names declared by a declaration are introduced into the scope in
-which the declaration occurs, except that the presence of a `friend`
-specifier [[class.friend]], certain uses of the
-*elaborated-type-specifier* [[dcl.type.elab]], and *using-directive*s
-[[namespace.udir]] alter this general behavior.
-Given a set of declarations in a single declarative region, each of
-which specifies the same unqualified name,
-- they shall all refer to the same entity, or all refer to functions and
-  function templates; or
-- exactly one declaration shall declare a class name or enumeration name
-  that is not a typedef name and the other declarations shall all refer
-  to the same variable, non-static data member, or enumerator, or all
-  refer to functions and function templates; in this case the class name
-  or enumeration name is hidden [[basic.scope.hiding]]. \[*Note 1*: A
-  structured binding [[dcl.struct.bind]], namespace name
-  [[basic.namespace]], or class template name [[temp.pre]] must be
-  unique in its declarative region. — *end note*]
-[*Note 2*: These restrictions apply to the declarative region into
-which a name is introduced, which is not necessarily the same as the
-region in which the declaration occurs. In particular,
-*elaborated-type-specifier*s [[dcl.type.elab]] and friend declarations
-[[class.friend]] may introduce a (possibly not visible) name into an
-enclosing namespace; these restrictions apply to that region. Local
-extern declarations [[basic.link]] may introduce a name into the
-declarative region where the declaration appears and also introduce a
-(possibly not visible) name into an enclosing namespace; these
-restrictions apply to both regions. — *end note*]
-For a given declarative region *R* and a point *P* outside *R*, the set
-of *intervening* declarative regions between *P* and *R* comprises all
-declarative regions that are or enclose *R* and do not enclose *P*.
-[*Note 3*: The name lookup rules are summarized in
-[[basic.lookup]]. — *end note*]
 ### 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;
@@ -96,12 +213,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;
@@ -112,25 +229,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;
@@ -140,113 +253,125 @@ 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*]
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
-A name declared in a block [[stmt.block]] is local to that block; it has
-*block scope*. Its potential scope begins at its point of declaration
-[[basic.scope.pdecl]] and ends at the end of its block. A variable
-declared at block scope is a *local variable*.
-The name declared in an *exception-declaration* is local to the
-*handler* and shall not be redeclared in the outermost block of the
-*handler*.
-Names declared in the *init-statement*, the *for-range-declaration*, and
-in the *condition* of `if`, `while`, `for`, and `switch` statements are
-local to the `if`, `while`, `for`, or `switch` statement (including the
-controlled statement), and shall not be redeclared in a subsequent
-condition of that statement nor in the outermost block (or, for the `if`
-statement, any of the outermost blocks) of the controlled statement.
 [*Example 1*:
 ``` cpp
 if (int x = f()) {
   int x;            // error: redeclaration of x
 }
 else {
@@ -256,314 +381,112 @@ else {
 — *end example*]
 ### Function parameter scope <a id="basic.scope.param">[[basic.scope.param]]</a>
-A function parameter (including one appearing in a *lambda-declarator*)
-or function-local predefined variable [[dcl.fct.def]] has *function
-parameter scope*. The potential scope of a parameter or function-local
-predefined variable begins at its point of declaration. If the nearest
-enclosing function declarator is not the declarator of a function
-definition, the potential scope ends at the end of that function
-declarator. Otherwise, if the function has a *function-try-block* the
-potential scope ends at the end of the last associated handler.
-Otherwise the potential scope ends at the end of the outermost block of
-the function definition. A parameter name shall not be redeclared in the
-outermost block of the function definition nor in the outermost block of
-any handler associated with a *function-try-block*.
-### Function scope <a id="basic.funscope">[[basic.funscope]]</a>
-Labels [[stmt.label]] have *function scope* and may be used anywhere in
-the function in which they are declared. Only labels have function
-scope.
 ### Namespace scope <a id="basic.scope.namespace">[[basic.scope.namespace]]</a>
-The declarative region of a *namespace-definition* is its
-*namespace-body*. Entities declared in a *namespace-body* are said to be
-*members* of the namespace, and names introduced by these declarations
-into the declarative region of the namespace are said to be *member
-names* of the namespace. A namespace member name has namespace scope.
-Its potential scope includes its namespace from the name’s point of
-declaration [[basic.scope.pdecl]] onwards; and for each
-*using-directive* [[namespace.udir]] that nominates the member’s
-namespace, the member’s potential scope includes that portion of the
-potential scope of the *using-directive* that follows the member’s point
-of declaration.
 [*Example 1*:
 ``` cpp
-namespace N {
- int i;
- int g(int a) { return a; }
-  int j();
-  void q();
   }
-namespace { int l=1; }
-// the potential scope of l is from its point of declaration to the end of the translation unit
-namespace N {
-  int g(char a) {   // overloads N::g(int)
-    return l+a;     // l is from unnamed namespace
-  }
-  int i;            // error: duplicate definition
-  int j();          // OK: duplicate function declaration
-  int j() {         // OK: definition of N::j()
-    return g(i);    // calls N::g(int)
-  }
-  int q();          // error: different return type
 }
 ```
 — *end example*]
-If a translation unit Q is imported into a translation unit R
-[[module.import]], the potential scope of a name X declared with
-namespace scope in Q is extended to include the portion of the
-corresponding namespace scope in R following the first
-*module-import-declaration* or *module-declaration* in R that imports Q
-(directly or indirectly) if
-- X does not have internal linkage, and
-- X is declared after the *module-declaration* in Q (if any), and
-- either X is exported or Q and R are part of the same module.
-[*Note 1*:
-A *module-import-declaration* imports both the named translation unit(s)
-and any modules named by exported *module-import-declaration*s within
-them, recursively.
-[*Example 2*:
-Translation unit #1
-``` cpp
-export module Q;
-export int sq(int i) { return i*i; }
-```
-Translation unit #2
-``` cpp
-export module R;
-export import Q;
-```
-Translation unit #3
-``` cpp
-import R;
-int main() { return sq(9); }    // OK: sq from module Q
-```
-— *end example*]
-— *end note*]
-A namespace member can also be referred to after the `::` scope
-resolution operator [[expr.prim.id.qual]] applied to the name of its
-namespace or the name of a namespace which nominates the member’s
-namespace in a *using-directive*; see  [[namespace.qual]].
-The outermost declarative region of a translation unit is also a
-namespace, called the *global namespace*. A name declared in the global
-namespace has *global namespace scope* (also called *global scope*). The
-potential scope of such a name begins at its point of declaration
-[[basic.scope.pdecl]] and ends at the end of the translation unit that
-is its declarative region. A name with global namespace scope is said to
-be a *global name*.
 ### Class scope <a id="basic.scope.class">[[basic.scope.class]]</a>
-The potential scope of a name declared in a class consists not only of
-the declarative region following the name’s point of declaration, but
-also of all complete-class contexts [[class.mem]] of that class.
-A name `N` used in a class `S` shall refer to the same declaration in
-its context and when re-evaluated in the completed scope of `S`. No
-diagnostic is required for a violation of this rule.
-A name declared within a member function hides a declaration of the same
-name whose scope extends to or past the end of the member function’s
-class.
-The potential scope of a declaration in a class that extends to or past
-the end of a class definition also extends to the regions defined by its
-member definitions, even if the members are defined lexically outside
-the class (this includes static data member definitions, nested class
-definitions, and member function definitions, including the member
-function body and any portion of the declarator part of such definitions
-which follows the *declarator-id*, including a
-*parameter-declaration-clause* and any default arguments
-[[dcl.fct.default]]).
 [*Example 1*:
 ``` cpp
-typedef int  c;
-enum { i = 1 };
-class X {
-  char  v[i];                       // error: i refers to ::i but when reevaluated is X::i
-  int  f() { return sizeof(c); }    // OK: X::c
-  char  c;
-  enum { i = 2 };
-};
-typedef char*  T;
-struct Y {
-  T  a;                             // error: T refers to ::T but when reevaluated is Y::T
-  typedef long  T;
-  T  b;
 };
-typedef int I;
-class D {
-  typedef I I;                      // error, even though no reordering involved
-};
 ```
 — *end example*]
-The name of a class member shall only be used as follows:
-- in the scope of its class (as described above) or a class derived
-  [[class.derived]] from its class,
-- after the `.` operator applied to an expression of the type of its
-  class [[expr.ref]] or a class derived from its class,
-- after the `->` operator applied to a pointer to an object of its class
-  [[expr.ref]] or a class derived from its class,
-- after the `::` scope resolution operator [[expr.prim.id.qual]] applied
-  to the name of its class or a class derived from its class.
 ### Enumeration scope <a id="basic.scope.enum">[[basic.scope.enum]]</a>
-The name of a scoped enumerator [[dcl.enum]] has *enumeration scope*.
-Its potential scope begins at its point of declaration and terminates at
-the end of the *enum-specifier*.
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
-The declarative region of the name of a template parameter of a template
-*template-parameter* is the smallest *template-parameter-list* in which
-the name was introduced.
-The declarative region of the name of a template parameter of a template
-is the smallest *template-declaration* in which the name was introduced.
-Only template parameter names belong to this declarative region; any
-other kind of name introduced by the *declaration* of a
-*template-declaration* is instead introduced into the same declarative
-region where it would be introduced as a result of a non-template
-declaration of the same name.
-[*Example 1*:
-``` cpp
-namespace N {
-  template<class T> struct A { };               // #1
-  template<class U> void f(U) { }               // #2
-  struct B {
-    template<class V> friend int g(struct C*);  // #3
-  };
-}
-```
-The declarative regions of `T`, `U` and `V` are the
-*template-declaration*s on lines \#1, \#2, and \#3, respectively. But
-the names `A`, `f`, `g` and `C` all belong to the same declarative
-region — namely, the *namespace-body* of `N`. (`g` is still considered
-to belong to this declarative region in spite of its being hidden during
-qualified and unqualified name lookup.)
-— *end example*]
-The potential scope of a template parameter name begins at its point of
-declaration [[basic.scope.pdecl]] and ends at the end of its declarative
-region.
-[*Note 1*:
-This implies that a *template-parameter* can be used in the declaration
-of subsequent *template-parameter*s and their default arguments but
-cannot be used in preceding *template-parameter*s or their default
-arguments. For example,
-``` cpp
-template<class T, T* p, class U = T> class X { ... };
-template<class T> void f(T* p = new T);
-```
-This also implies that a *template-parameter* can be used in the
-specification of base classes. For example,
-``` cpp
-template<class T> class X : public Array<T> { ... };
-template<class T> class Y : public T { ... };
-```
-The use of a template parameter as a base class implies that a class
-used as a template argument must be defined and not just declared when
-the class template is instantiated.
-— *end note*]
-The declarative region of the name of a template parameter is nested
-within the immediately-enclosing declarative region.
-[*Note 2*:
-As a result, a *template-parameter* hides any entity with the same name
-in an enclosing scope [[basic.scope.hiding]].
-[*Example 2*:
-``` cpp
-typedef int N;
-template<N X, typename N, template<N Y> class T> struct A;
-```
-Here, `X` is a non-type template parameter of type `int` and `Y` is a
-non-type template parameter of the same type as the second template
-parameter of `A`.
-— *end example*]
-— *end note*]
-[*Note 3*: Because the name of a template parameter cannot be
-redeclared within its potential scope [[temp.local]], a template
-parameter’s scope is often its potential scope. However, it is still
-possible for a template parameter name to be hidden; see
-[[temp.local]]. — *end note*]
-### Name hiding <a id="basic.scope.hiding">[[basic.scope.hiding]]</a>
-A declaration of a name in a nested declarative region hides a
-declaration of the same name in an enclosing declarative region; see
-[[basic.scope.declarative]] and [[basic.lookup.unqual]].
-If a class name [[class.name]] or enumeration name [[dcl.enum]] and a
-variable, data member, function, or enumerator are declared in the same
-declarative region (in any order) with the same name (excluding
-declarations made visible via *using-directive*s
-[[basic.lookup.unqual]]), the class or enumeration name is hidden
-wherever the variable, data member, function, or enumerator name is
-visible.
-In a member function definition, the declaration of a name at block
-scope hides the declaration of a member of the class with the same name;
-see  [[basic.scope.class]]. The declaration of a member in a derived
-class [[class.derived]] hides the declaration of a member of a base
-class of the same name; see  [[class.member.lookup]].
-During the lookup of a name qualified by a namespace name, declarations
-that would otherwise be made visible by a *using-directive* can be
-hidden by declarations with the same name in the namespace containing
-the *using-directive*; see  [[namespace.qual]].
-If a name is in scope and is not hidden it is said to be *visible*.

 ## Scope <a id="basic.scope">[[basic.scope]]</a>
+### General <a id="basic.scope.scope">[[basic.scope.scope]]</a>
+The declarations in a program appear in a number of *scopes* that are in
+general discontiguous. The *global scope* contains the entire program;
+every other scope S is introduced by a declaration,
+*parameter-declaration-clause*, *statement*, or *handler* (as described
+in the following subclauses of [[basic.scope]]) appearing in another
+scope which thereby contains S. An *enclosing scope* at a program point
+is any scope that contains it; the smallest such scope is said to be the
+*immediate scope* at that point. A scope *intervenes* between a program
+point P and a scope S (that does not contain P) if it is or contains S
+but does not contain P.
+Unless otherwise specified:
+- The smallest scope that contains a scope S is the *parent scope* of S.
+- No two declarations (re)introduce the same entity.
+- A declaration *inhabits* the immediate scope at its locus
+  [[basic.scope.pdecl]].
+- A declaration’s *target scope* is the scope it inhabits.
+- Any names (re)introduced by a declaration are *bound* to it in its
+  target scope.
+An entity *belongs* to a scope S if S is the target scope of a
+declaration of the entity.
+[*Note 1*:
+Special cases include that:
+- Template parameter scopes are parents only to other template parameter
+  scopes [[basic.scope.temp]].
+- Corresponding declarations with appropriate linkage declare the same
+  entity [[basic.link]].
+- The declaration in a *template-declaration* inhabits the same scope as
+  the *template-declaration*.
+- Friend declarations and declarations of qualified names and template
+  specializations do not bind names [[dcl.meaning]]; those with
+  qualified names target a specified scope, and other friend
+  declarations and certain *elaborated-type-specifier*s
+  [[dcl.type.elab]] target a larger enclosing scope.
+- Block-scope extern declarations target a larger enclosing scope but
+  bind a name in their immediate scope.
+- The names of unscoped enumerators are bound in the two innermost
+  enclosing scopes [[dcl.enum]].
+- A class’s name is also bound in its own scope [[class.pre]].
+- The names of the members of an anonymous union are bound in the
+  union’s parent scope [[class.union.anon]].
+— *end note*]
+Two non-static member functions have *corresponding object parameters*
+if:
+- exactly one is an implicit object member function with no
+  *ref-qualifier* and the types of their object parameters [[dcl.fct]],
+  after removing top-level references, are the same, or
+- their object parameters have the same type.
+Two non-static member function templates have *corresponding object
+parameters* if:
+- exactly one is an implicit object member function with no
+  *ref-qualifier* and the types of their object parameters, after
+  removing any references, are equivalent, or
+- the types of their object parameters are equivalent.
+Two function templates have *corresponding signatures* if their
+*template-parameter-list*s have the same length, their corresponding
+*template-parameter*s are equivalent, they have equivalent
+non-object-parameter-type-lists and return types (if any), and, if both
+are non-static members, they have corresponding object parameters.
+Two declarations *correspond* if they (re)introduce the same name, both
+declare constructors, or both declare destructors, unless
+- either is a *using-declarator*, or
+- one declares a type (not a *typedef-name*) and the other declares a
+  variable, non-static data member other than of an anonymous union
+  [[class.union.anon]], enumerator, function, or function template, or
+- each declares a function or function template, except when
+  - both declare functions with the same
+    non-object-parameter-type-list,[^3] equivalent [[temp.over.link]]
+    trailing *requires-clause*s (if any, except as specified in
+    [[temp.friend]]), and, if both are non-static members, they have
+    corresponding object parameters, or
+  - both declare function templates with corresponding signatures and
+    equivalent *template-head*s and trailing *requires-clause*s (if
+    any).
+[*Note 2*:
+Declarations can correspond even if neither binds a name.
 [*Example 1*:
+``` cpp
+struct A {
+  friend void f();      // #1
+};
+struct B {
+  friend void f() {}    // corresponds to, and defines, #1
+};
+```
+— *end example*]
+— *end note*]
+[*Example 2*:
 ``` cpp
+typedef int Int;
+enum E : int { a };
+void f(int);                    // #1
+void f(Int) {}                  // defines #1
+void f(E) {}                    // OK, another overload
+struct X {
+  static void f();
+  void f() const;               // error: redeclaration
+  void g();
+  void g() const;               // OK
+  void g() &;                   // error: redeclaration
+  void h(this X&, int);
+  void h(int) &&;               // OK, another overload
+  void j(this const X&);
+  void j() const &;             // error: redeclaration
+  void k();
+  void k(this X&);              // error: redeclaration
+};
+```
+— *end example*]
+Two declarations *potentially conflict* if they correspond and cause
+their shared name to denote different entities [[basic.link]]. The
+program is ill-formed if, in any scope, a name is bound to two
+declarations that potentially conflict and one precedes the other
+[[basic.lookup]].
+[*Note 3*: Overload resolution can consider potentially conflicting
+declarations found in multiple scopes (e.g., via *using-directive*s or
+for operator functions), in which case it is often
+ambiguous. — *end note*]
+[*Example 3*:
+``` cpp
+void f() {
+  int x,y;
+  void x();             // error: different entity for x
+  int y;                // error: redefinition
+}
+enum { f };             // error: different entity for ::f
+namespace A {}
+namespace B = A;
+namespace B = A;        // OK, no effect
+namespace B = B;        // OK, no effect
+namespace A = B;        // OK, no effect
+namespace B {}          // error: different entity for B
+```
+— *end example*]
+A declaration is *nominable* in a class, class template, or namespace E
+at a point P if it precedes P, it does not inhabit a block scope, and
+its target scope is the scope associated with E or, if E is a namespace,
+any element of the inline namespace set of E [[namespace.def]].
+[*Example 4*:
+``` cpp
+namespace A {
+  void f() {void g();}
+  inline namespace B {
+    struct S {
+      friend void h();
+      static int i;
+    };
+  }
 }
 ```
+At the end of this example, the declarations of `f`, `B`, `S`, and `h`
+are nominable in `A`, but those of `g` and `i` are not.
 — *end example*]
+When instantiating a templated entity [[temp.pre]], any scope S
+introduced by any part of the template definition is considered to be
+introduced by the instantiated entity and to contain the instantiations
+of any declarations that inhabit S.
 ### 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*]
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
+Each
+- selection or iteration statement [[stmt.select]], [[stmt.iter]],
+- substatement of such a statement,
+- *handler* [[except.pre]], or
+- compound statement [[stmt.block]] that is not the *compound-statement*
+  of a *handler*
+introduces a *block scope* that includes that statement or *handler*.
+[*Note 1*: A substatement that is also a block has only one
+scope. — *end note*]
+A variable that belongs to a block scope is a *block variable*.
 [*Example 1*:
+``` cpp
+int i = 42;
+int a[10];
+for (int i = 0; i < 10; i++)
+  a[i] = i;
+int j = i;          // j = 42
+```
+— *end example*]
+If a declaration whose target scope is the block scope S of a
+- *compound-statement* of a *lambda-expression*, *function-body*, or
+  *function-try-block*,
+- substatement of a selection or iteration statement that is not itself
+  a selection or iteration statement, or
+- *handler* of a *function-try-block*
+potentially conflicts with a declaration whose target scope is the
+parent scope of S, the program is ill-formed.
+[*Example 2*:
 ``` cpp
 if (int x = f()) {
   int x;            // error: redeclaration of x
 }
 else {
 — *end example*]
 ### Function parameter scope <a id="basic.scope.param">[[basic.scope.param]]</a>
+A *parameter-declaration-clause* P introduces a
+*function parameter scope* that includes P.
+[*Note 1*: A function parameter cannot be used for its value within the
+*parameter-declaration-clause* [[dcl.fct.default]]. — *end note*]
+- If P is associated with a *declarator* and is preceded by a
+  (possibly-parenthesized) *noptr-declarator* of the form
+  *declarator-id* *attribute-specifier-seq*ₒₚₜ , its scope extends to
+  the end of the nearest enclosing *init-declarator*,
+  *member-declarator*, *declarator* of a *parameter-declaration* or a
+  *nodeclspec-function-declaration*, or *function-definition*, but does
+  not include the locus of the associated *declarator*. \[*Note 2*: In
+  this case, P declares the parameters of a function (or a function or
+  template parameter declared with function type). A member function’s
+  parameter scope is nested within its class’s scope. — *end note*]
+- If P is associated with a *lambda-declarator*, its scope extends to
+  the end of the *compound-statement* in the *lambda-expression*.
+- If P is associated with a *requirement-parameter-list*, its scope
+  extends to the end of the *requirement-body* of the
+  requires-expression.
+- If P is associated with a *deduction-guide*, its scope extends to the
+  end of the *deduction-guide*.
+### Lambda scope <a id="basic.scope.lambda">[[basic.scope.lambda]]</a>
+A *lambda-expression* `E` introduces a *lambda scope* that starts
+immediately after the *lambda-introducer* of `E` and extends to the end
+of the *compound-statement* of `E`.
 ### Namespace scope <a id="basic.scope.namespace">[[basic.scope.namespace]]</a>
+Any *namespace-definition* for a namespace N introduces a
+*namespace scope* that includes the *namespace-body* for every
+*namespace-definition* for N. For each non-friend redeclaration or
+specialization whose target scope is or is contained by the scope, the
+portion after the *declarator-id*, *class-head-name*, or
+*enum-head-name* is also included in the scope. The global scope is the
+namespace scope of the global namespace [[basic.namespace]].
 [*Example 1*:
 ``` cpp
+namespace Q {
+ namespace V { void f(); }
+ void V::f() {         // in the scope of V
+    void h();           // declares Q::V::h
   }
 }
 ```
 — *end example*]
 ### Class scope <a id="basic.scope.class">[[basic.scope.class]]</a>
+Any declaration of a class or class template C introduces a
+*class scope* that includes the *member-specification* of the
+*class-specifier* for C (if any). For each non-friend redeclaration or
+specialization whose target scope is or is contained by the scope, the
+portion after the *declarator-id*, *class-head-name*, or
+*enum-head-name* is also included in the scope.
+[*Note 1*:
+Lookup from a program point before the *class-specifier* of a class will
+find no bindings in the class scope.
 [*Example 1*:
 ``` cpp
+template<class D>
+struct B {
+  D::type x;            // #1
 };
+struct A { using type = int; };
+struct C : A, B<C> {};  // error at #1: C::type not found
 ```
 — *end example*]
+— *end note*]
 ### Enumeration scope <a id="basic.scope.enum">[[basic.scope.enum]]</a>
+Any declaration of an enumeration E introduces an *enumeration scope*
+that includes the *enumerator-list* of the *enum-specifier* for E (if
+any).
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
+Each template *template-parameter* introduces a
+*template parameter scope* that includes the *template-head* of the
+*template-parameter*.
+Each *template-declaration* D introduces a template parameter scope that
+extends from the beginning of its *template-parameter-list* to the end
+of the *template-declaration*. Any declaration outside the
+*template-parameter-list* that would inhabit that scope instead inhabits
+the same scope as D. The parent scope of any scope S that is not a
+template parameter scope is the smallest scope that contains S and is
+not a template parameter scope.
+[*Note 1*: Therefore, only template parameters belong to a template
+parameter scope, and only template parameter scopes have a template
+parameter scope as a parent scope. — *end note*]

Diff to HTML by rtfpessoa