[basic.lookup] - C++17 → C++20

Files changed (1) hide show

tmp/tmp9nqphu35/{from.md → to.md} +267 -195

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

@@ -1,29 +1,29 @@
 ## Name lookup <a id="basic.lookup">[[basic.lookup]]</a>
 The name lookup rules apply uniformly to all names (including
-*typedef-name*s ([[dcl.typedef]]), *namespace-name*s (
-[[basic.namespace]]), and *class-name*s ([[class.name]])) wherever the
-grammar allows such names in the context discussed by a particular rule.
-Name lookup associates the use of a name with a set of declarations (
-[[basic.def]]) of that name. The declarations found by name lookup shall
-either all declare the same entity or shall all declare functions; in
-the latter case, the declarations are said to form a set of overloaded
-functions ([[over.load]]). Overload resolution ([[over.match]]) takes
-place after name lookup has succeeded. The access rules (Clause
-[[class.access]]) are considered only once name lookup and function
 overload resolution (if applicable) have succeeded. Only after name
 lookup, function overload resolution (if applicable) and access checking
-have succeeded are the attributes introduced by the name’s declaration
-used further in expression processing (Clause  [[expr]]).
-A name “looked up in the context of an expression” is looked up as an
-unqualified name in the scope where the expression is found.
-The injected-class-name of a class (Clause  [[class]]) is also
-considered to be a member of that class for the purposes of name hiding
-and lookup.
 [*Note 1*:  [[basic.link]] discusses linkage issues. The notions of
 scope, point of declaration and name hiding are discussed in
 [[basic.scope]]. — *end note*]
@@ -46,12 +46,31 @@ function call is described in  [[basic.lookup.argdep]].
 [*Note 1*:
 For purposes of determining (during parsing) whether an expression is a
 *postfix-expression* for a function call, the usual name lookup rules
-apply. The rules in  [[basic.lookup.argdep]] have no effect on the
-syntactic interpretation of an expression. For example,
 ``` cpp
 typedef int f;
 namespace N {
   struct A {
@@ -63,11 +82,11 @@ namespace N {
   };
 }
 ```
 Because the expression is not a function call, the argument-dependent
-name lookup ([[basic.lookup.argdep]]) does not apply and the friend
 function `f` is not found.
 — *end note*]
 A name used in global scope, outside of any function, class or
@@ -77,15 +96,15 @@ scope.
 A name used in a user-declared namespace outside of the definition of
 any function or class shall be declared before its use in that namespace
 or before its use in a namespace enclosing its namespace.
 In the definition of a function that is a member of namespace `N`, a
-name used after the function’s *declarator-id*[^4] shall be declared
 before its use in the block in which it is used or in one of its
-enclosing blocks ([[stmt.block]]) or shall be declared before its use
-in namespace `N` or, if `N` is a nested namespace, shall be declared
-before its use in one of `N`’s enclosing namespaces.
 [*Example 1*:
 ``` cpp
 namespace A {
@@ -103,22 +122,21 @@ void A::N::f() {
 }
 ```
 — *end example*]
-A name used in the definition of a class `X` outside of a member
-function body, default argument, *noexcept-specifier*,
-*brace-or-equal-initializer* of a non-static data member, or nested
-class definition[^5] shall be declared in one of the following ways:
-- before its use in class `X` or be a member of a base class of `X` (
-  [[class.member.lookup]]), or
-- if `X` is a nested class of class `Y` ([[class.nest]]), before the
   definition of `X` in `Y`, or shall be a member of a base class of `Y`
   (this lookup applies in turn to `Y`’s enclosing classes, starting with
-  the innermost enclosing class),[^6] or
-- if `X` is a local class ([[class.local]]) or is a nested class of a
   local class, before the definition of class `X` in a block enclosing
   the definition of class `X`, or
 - if `X` is a member of namespace `N`, or is a nested class of a class
   that is a member of `N`, or is a local class or a nested class within
   a local class of a function that is a member of `N`, before the
@@ -151,36 +169,34 @@ namespace N {
 ```
 — *end example*]
 [*Note 2*: When looking for a prior declaration of a class or function
-introduced by a `friend` declaration, scopes outside of the innermost
 enclosing namespace scope are not considered; see
 [[namespace.memdef]]. — *end note*]
 [*Note 3*:  [[basic.scope.class]] further describes the restrictions on
 the use of names in a class definition. [[class.nest]] further describes
 the restrictions on the use of names in nested class definitions.
 [[class.local]] further describes the restrictions on the use of names
 in local class definitions. — *end note*]
-For the members of a class `X`, a name used in a member function body,
-in a default argument, in a *noexcept-specifier*, in the
-*brace-or-equal-initializer* of a non-static data member (
-[[class.mem]]), or in the definition of a class member outside of the
-definition of `X`, following the member’s *declarator-id*[^7], shall be
-declared in one of the following ways:
 - before its use in the block in which it is used or in an enclosing
-  block ([[stmt.block]]), or
-- shall be a member of class `X` or be a member of a base class of `X` (
-  [[class.member.lookup]]), or
-- if `X` is a nested class of class `Y` ([[class.nest]]), shall be a
   member of `Y`, or shall be a member of a base class of `Y` (this
   lookup applies in turn to `Y`’s enclosing classes, starting with the
-  innermost enclosing class),[^8] or
-- if `X` is a local class ([[class.local]]) or is a nested class of a
   local class, before the definition of class `X` in a block enclosing
   the definition of class `X`, or
 - if `X` is a member of namespace `N`, or is a nested class of a class
   that is a member of `N`, or is a local class or a nested class within
   a local class of a function that is a member of `N`, before the use of
@@ -217,21 +233,21 @@ restrictions on the use of names in member function definitions.
 [[class.nest]] further describes the restrictions on the use of names in
 the scope of nested classes. [[class.local]] further describes the
 restrictions on the use of names in local class
 definitions. — *end note*]
-Name lookup for a name used in the definition of a `friend` function (
-[[class.friend]]) defined inline in the class granting friendship shall
 proceed as described for lookup in member function definitions. If the
-`friend` function is not defined in the class granting friendship, name
-lookup in the `friend` function definition shall proceed as described
-for lookup in namespace member function definitions.
-In a `friend` declaration naming a member function, a name used in the
 function declarator and not part of a *template-argument* in the
 *declarator-id* is first looked up in the scope of the member function’s
-class ([[class.member.lookup]]). If it is not found, or if the name is
 part of a *template-argument* in the *declarator-id*, the look up is as
 described for unqualified names in the definition of the class granting
 friendship.
 [*Example 4*:
@@ -252,14 +268,14 @@ struct B {
 };
 ```
 — *end example*]
-During the lookup for a name used as a default argument (
-[[dcl.fct.default]]) in a function *parameter-declaration-clause* or
-used in the *expression* of a *mem-initializer* for a constructor (
-[[class.base.init]]), the function parameter names are visible and hide
 the names of entities declared in the block, class or namespace scopes
 containing the function declaration.
 [*Note 5*:  [[dcl.fct.default]] further describes the restrictions on
 the use of names in default arguments. [[class.base.init]] further
@@ -269,13 +285,13 @@ describes the restrictions on the use of names in a
 During the lookup of a name used in the *constant-expression* of an
 *enumerator-definition*, previously declared *enumerator*s of the
 enumeration are visible and hide the names of entities declared in the
 block, class, or namespace scopes containing the *enum-specifier*.
-A name used in the definition of a `static` data member of class `X` (
-[[class.static.data]]) (after the *qualified-id* of the static member)
-is looked up as if the name was used in a member function of `X`.
 [*Note 6*:  [[class.static.data]] further describes the restrictions on
 the use of names in the definition of a `static` data
 member. — *end note*]
@@ -297,32 +313,32 @@ int i = 2;
 int N::j = i;       // N::j == 4
 ```
 — *end example*]
-A name used in the handler for a *function-try-block* (Clause
-[[except]]) is looked up as if the name was used in the outermost block
-of the function definition. In particular, the function parameter names
-shall not be redeclared in the *exception-declaration* nor in the
-outermost block of a handler for the *function-try-block*. Names
-declared in the outermost block of the function definition are not found
-when looked up in the scope of a handler for the *function-try-block*.
 [*Note 7*: But function parameter names are found. — *end note*]
 [*Note 8*: The rules for name lookup in template definitions are
 described in  [[temp.res]]. — *end note*]
 ### Argument-dependent name lookup <a id="basic.lookup.argdep">[[basic.lookup.argdep]]</a>
-When the *postfix-expression* in a function call ([[expr.call]]) is an
 *unqualified-id*, other namespaces not considered during the usual
-unqualified lookup ([[basic.lookup.unqual]]) may be searched, and in
-those namespaces, namespace-scope friend function or function template
-declarations ([[class.friend]]) not otherwise visible may be found.
-These modifications to the search depend on the types of the arguments
-(and for template template arguments, the namespace of the template
 argument).
 [*Example 1*:
 ``` cpp
@@ -340,62 +356,62 @@ void g() {
 — *end example*]
 For each argument type `T` in the function call, there is a set of zero
 or more *associated namespaces* and a set of zero or more *associated
-classes* to be considered. The sets of namespaces and classes are
-determined entirely by the types of the function arguments (and the
-namespace of any template template argument). Typedef names and
-*using-declaration*s used to specify the types do not contribute to this
-set. The sets of namespaces and classes are determined in the following
-way:
 - If `T` is a fundamental type, its associated sets of namespaces and
- classes are both empty.
-- If `T` is a class type (including unions), its associated classes are:
-  the class itself; the class of which it is a member, if any; and its
-  direct and indirect base classes. Its associated namespaces are the
-  innermost enclosing namespaces of its associated classes. Furthermore,
-  if `T` is a class template specialization, its associated namespaces
-  and classes also include: the namespaces and classes associated with
-  the types of the template arguments provided for template type
-  parameters (excluding template template parameters); the namespaces of
- which any template template arguments are members; and the classes of
- which any member templates used as template template arguments are
- members. \[*Note 1*: Non-type template arguments do not contribute to
- the set of associated namespaces. — *end note*]
 - If `T` is an enumeration type, its associated namespace is the
-  innermost enclosing namespace of its declaration. If it is a class
- member, its associated class is the member’s class; else it has no
-  associated class.
 - If `T` is a pointer to `U` or an array of `U`, its associated
-  namespaces and classes are those associated with `U`.
-- If `T` is a function type, its associated namespaces and classes are
   those associated with the function parameter types and those
   associated with the return type.
 - If `T` is a pointer to a member function of a class `X`, its
-  associated namespaces and classes are those associated with the
   function parameter types and return type, together with those
   associated with `X`.
 - If `T` is a pointer to a data member of class `X`, its associated
-  namespaces and classes are those associated with the member type
   together with those associated with `X`.
-If an associated namespace is an inline namespace ([[namespace.def]]),
-its enclosing namespace is also included in the set. If an associated
 namespace directly contains inline namespaces, those inline namespaces
 are also included in the set. In addition, if the argument is the name
-or address of a set of overloaded functions and/or function templates,
-its associated classes and namespaces are the union of those associated
-with each of the members of the set, i.e., the classes and namespaces
-associated with its parameter types and return type. Additionally, if
-the aforementioned set of overloaded functions is named with a
-*template-id*, its associated classes and namespaces also include those
-of its type *template-argument*s and its template *template-argument*s.
-Let *X* be the lookup set produced by unqualified lookup (
-[[basic.lookup.unqual]]) and let *Y* be the lookup set produced by
 argument dependent lookup (defined as follows). If *X* contains
 - a declaration of a class member, or
 - a block-scope function declaration that is not a *using-declaration*,
   or
@@ -404,12 +420,12 @@ argument dependent lookup (defined as follows). If *X* contains
 then *Y* is empty. Otherwise *Y* is the set of declarations found in the
 namespaces associated with the argument types as described below. The
 set of declarations found by the lookup of the name is the union of *X*
 and *Y*.
-[*Note 2*: The namespaces and classes associated with the argument
-types can include namespaces and classes already considered by the
 ordinary unqualified lookup. — *end note*]
 [*Example 2*:
 ``` cpp
@@ -427,27 +443,88 @@ int main() {
 }
 ```
 — *end example*]
-When considering an associated namespace, the lookup is the same as the
-lookup performed when the associated namespace is used as a qualifier (
-[[namespace.qual]]) except that:
-- Any *using-directive*s in the associated namespace are ignored.
-- Any namespace-scope friend functions or friend function templates
-  declared in associated classes are visible within their respective
-  namespaces even if they are not visible during an ordinary lookup (
-  [[class.friend]]).
 - All names except those of (possibly overloaded) functions and function
   templates are ignored.
 ### Qualified name lookup <a id="basic.lookup.qual">[[basic.lookup.qual]]</a>
 The name of a class or namespace member or enumerator can be referred to
-after the `::` scope resolution operator ([[expr.prim]]) applied to a
-*nested-name-specifier* that denotes its class, namespace, or
 enumeration. If a `::` scope resolution operator in a
 *nested-name-specifier* is not preceded by a *decltype-specifier*,
 lookup of the name preceding that `::` considers only namespaces, types,
 and templates whose specializations are types. If the name found does
 not designate a namespace or a class, enumeration, or dependent type,
@@ -461,19 +538,19 @@ public:
   static int n;
 };
 int main() {
   int A;
   A::n = 42;        // OK
-  A b;              // ill-formed: A does not name a type
 }
 ```
 — *end example*]
 [*Note 1*: Multiply qualified names, such as `N1::N2::N3::n`, can be
-used to refer to members of nested classes ([[class.nest]]) or members
-of nested namespaces. — *end note*]
 In a declaration in which the *declarator-id* is a *qualified-id*, names
 used before the *qualified-id* being declared are looked up in the
 defining namespace scope; names following the *qualified-id* are looked
 up in the scope of the member’s class or namespace.
@@ -485,38 +562,35 @@ class X { };
 class C {
   class X { };
   static const int number = 50;
   static X arr[number];
 };
-X C::arr[number];   // ill-formed:
                     // equivalent to ::X C::arr[C::number];
                     // and not to C::X C::arr[C::number];
 ```
 — *end example*]
-A name prefixed by the unary scope operator `::` ([[expr.prim]]) is
-looked up in global scope, in the translation unit where it is used. The
-name shall be declared in global namespace scope or shall be a name
 whose declaration is visible in global scope because of a
-*using-directive* ([[namespace.qual]]). The use of `::` allows a global
-name to be referred to even if its identifier has been hidden (
-[[basic.scope.hiding]]).
 A name prefixed by a *nested-name-specifier* that nominates an
 enumeration type shall represent an *enumerator* of that enumeration.
-If a *pseudo-destructor-name* ([[expr.pseudo]]) contains a
-*nested-name-specifier*, the *type-name*s are looked up as types in the
-scope designated by the *nested-name-specifier*. Similarly, in a
-*qualified-id* of the form:
 ``` bnf
-nested-name-specifierₒₚₜ class-name '::' '~' class-name
 ```
-the second *class-name* is looked up in the same scope as the first.
 [*Example 3*:
 ``` cpp
 struct C {
@@ -545,40 +619,39 @@ proceeds after the `.` and `->` operators. — *end note*]
 #### Class members <a id="class.qual">[[class.qual]]</a>
 If the *nested-name-specifier* of a *qualified-id* nominates a class,
 the name specified after the *nested-name-specifier* is looked up in the
-scope of the class ([[class.member.lookup]]), except for the cases
-listed below. The name shall represent one or more members of that class
-or of one of its base classes (Clause  [[class.derived]]).
 [*Note 1*: A class member can be referred to using a *qualified-id* at
-any point in its potential scope (
-[[basic.scope.class]]). — *end note*]
 The exceptions to the name lookup rule above are the following:
 - the lookup for a destructor is as specified in  [[basic.lookup.qual]];
 - a *conversion-type-id* of a *conversion-function-id* is looked up in
   the same manner as a *conversion-type-id* in a class member access
   (see  [[basic.lookup.classref]]);
 - the names in a *template-argument* of a *template-id* are looked up in
-  the context in which the entire *postfix-expression* occurs.
-- the lookup for a name specified in a *using-declaration* (
-  [[namespace.udecl]]) also finds class or enumeration names hidden
-  within the same scope ([[basic.scope.hiding]]).
-In a lookup in which function names are not ignored[^9] and the
 *nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
-  up in `C`, is the injected-class-name of `C` (Clause  [[class]]), or
-- in a *using-declarator* of a *using-declaration* (
- [[namespace.udecl]]) that is a *member-declaration*, if the name
- specified after the *nested-name-specifier* is the same as the
-  *identifier* or the *simple-template-id*’s *template-name* in the last
- component of the *nested-name-specifier*,
 the name is instead considered to name the constructor of class `C`.
 [*Note 2*: For example, the constructor is not an acceptable lookup
 result in an *elaborated-type-specifier* so the constructor would not be
@@ -595,11 +668,11 @@ struct B: public A { B(); };
 A::A() { }
 B::B() { }
 B::A ba;            // object of type A
-A::A a;             // error, A::A is not a type name
 struct A::A a2;     // object of type A
 ```
 — *end example*]
@@ -616,22 +689,24 @@ nominating the global namespace), the name specified after the
 names in a *template-argument* of a *template-id* are looked up in the
 context in which the entire *postfix-expression* occurs.
 For a namespace `X` and name `m`, the namespace-qualified lookup set
 S(X, m) is defined as follows: Let S'(X, m) be the set of all
-declarations of `m` in `X` and the inline namespace set of `X` (
-[[namespace.def]]). If S'(X, m) is not empty, S(X, m) is S'(X, m);
 otherwise, S(X, m) is the union of S(Nᵢ, m) for all namespaces Nᵢ
 nominated by *using-directive*s in `X` and its inline namespace set.
 Given `X::m` (where `X` is a user-declared namespace), or given `::m`
 (where X is the global namespace), if S(X, m) is the empty set, the
 program is ill-formed. Otherwise, if S(X, m) has exactly one member, or
-if the context of the reference is a *using-declaration* (
-[[namespace.udecl]]), S(X, m) is the required set of declarations of
-`m`. Otherwise if the use of `m` is not one that allows a unique
-declaration to be chosen from S(X, m), the program is ill-formed.
 [*Example 1*:
 ``` cpp
 int x;
@@ -767,11 +842,11 @@ void f()
 — *end example*]
 During the lookup of a qualified namespace member name, if the lookup
 finds more than one declaration of the member, and if one declaration
 introduces a class name or enumeration name and the other declarations
-either introduce the same variable, the same enumerator or a set of
 functions, the non-type name hides the class or enumeration name if and
 only if the declarations are from the same namespace; otherwise (the
 declarations are from different namespaces), the program is ill-formed.
 [*Example 4*:
@@ -804,23 +879,23 @@ has the form
 ``` bnf
 nested-name-specifier unqualified-id
 ```
 the *unqualified-id* shall name a member of the namespace designated by
-the *nested-name-specifier* or of an element of the inline namespace
-set ([[namespace.def]]) of that namespace.
 [*Example 5*:
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
   using namespace B;
 }
-void A::f1(int){ }  // ill-formed, f1 is not a member of A
 ```
 — *end example*]
 However, in such namespace member declarations, the
@@ -849,14 +924,13 @@ void B::f1(int){ }  // OK, defines A::B::f1(int)
 — *end example*]
 ### Elaborated type specifiers <a id="basic.lookup.elab">[[basic.lookup.elab]]</a>
-An *elaborated-type-specifier* ([[dcl.type.elab]]) may be used to refer
-to a previously declared *class-name* or *enum-name* even though the
-name has been hidden by a non-type declaration (
-[[basic.scope.hiding]]).
 If the *elaborated-type-specifier* has no *nested-name-specifier*, and
 unless the *elaborated-type-specifier* appears in a declaration with the
 following form:
@@ -888,18 +962,17 @@ declared. If the name lookup does not find a previously declared
 [*Example 1*:
 ``` cpp
 struct Node {
-  struct Node* Next;            // OK: Refers to Node at global scope
-  struct Data* Data;            // OK: Declares type Data
-                                // at global scope and member Data
 };
 struct Data {
   struct Node* Node;            // OK: Refers to Node at global scope
-  friend struct ::Glob;         // error: Glob is not declared, cannot introduce a qualified type~([dcl.type.elab])
   friend struct Glob;           // OK: Refers to (as yet) undeclared Glob at global scope.
   ...
 };
 struct Base {
@@ -910,34 +983,33 @@ struct Base {
   friend class Data;            // OK: nested Data is a friend
   struct Data { ... };    // Defines nested Data
 };
 struct Data;                    // OK: Redeclares Data at global scope
-struct ::Data;                  // error: cannot introduce a qualified type~([dcl.type.elab])
-struct Base::Data;              // error: cannot introduce a qualified type~([dcl.type.elab])
 struct Base::Datum;             // error: Datum undefined
 struct Base::Data* pBase;       // OK: refers to nested Data
 ```
 — *end example*]
 ### Class member access <a id="basic.lookup.classref">[[basic.lookup.classref]]</a>
-In a class member access expression ([[expr.ref]]), if the `.` or `->`
 token is immediately followed by an *identifier* followed by a `<`, the
 identifier must be looked up to determine whether the `<` is the
-beginning of a template argument list ([[temp.names]]) or a less-than
 operator. The identifier is first looked up in the class of the object
-expression. If the identifier is not found, it is then looked up in the
-context of the entire *postfix-expression* and shall name a class
-template.
-If the *id-expression* in a class member access ([[expr.ref]]) is an
 *unqualified-id*, and the type of the object expression is of a class
-type `C`, the *unqualified-id* is looked up in the scope of class `C`.
-For a pseudo-destructor call ([[expr.pseudo]]), the *unqualified-id* is
-looked up in the context of the complete *postfix-expression*.
 If the *unqualified-id* is `~`*type-name*, the *type-name* is looked up
 in the context of the entire *postfix-expression*. If the type `T` of
 the object expression is of a class type `C`, the *type-name* is also
 looked up in the scope of class `C`. At least one of the lookups shall
@@ -965,14 +1037,14 @@ the form
 ``` cpp
 class-name-or-namespace-name::...
 ```
-the *class-name-or-namespace-name* following the `.` or `->` operator is
-first looked up in the class of the object expression and the name, if
-found, is used. Otherwise it is looked up in the context of the entire
-*postfix-expression*.
 [*Note 1*: See  [[basic.lookup.qual]], which describes the lookup of a
 name before `::`, which will only find a type or namespace
 name. — *end note*]
@@ -980,23 +1052,23 @@ If the *qualified-id* has the form
 ``` cpp
 ::class-name-or-namespace-name::...
 ```
-the *class-name-or-namespace-name* is looked up in global scope as a
 *class-name* or *namespace-name*.
-If the *nested-name-specifier* contains a *simple-template-id* (
-[[temp.names]]), the names in its *template-argument*s are looked up in
 the context in which the entire *postfix-expression* occurs.
 If the *id-expression* is a *conversion-function-id*, its
 *conversion-type-id* is first looked up in the class of the object
-expression and the name, if found, is used. Otherwise it is looked up in
-the context of the entire *postfix-expression*. In each of these
-lookups, only names that denote types or templates whose specializations
-are types are considered.
 [*Example 2*:
 ``` cpp
 struct A { };

 ## Name lookup <a id="basic.lookup">[[basic.lookup]]</a>
 The name lookup rules apply uniformly to all names (including
+*typedef-name*s [[dcl.typedef]], *namespace-name*s [[basic.namespace]],
+and *class-name*s [[class.name]]) wherever the grammar allows such names
+in the context discussed by a particular rule. Name lookup associates
+the use of a name with a set of declarations [[basic.def]] of that name.
+If the declarations found by name lookup all denote functions or
+function templates, the declarations are said to form an *overload set*.
+The declarations found by name lookup shall either all denote the same
+entity or form an overload set. Overload resolution ([[over.match]],
+[[over.over]]) takes place after name lookup has succeeded. The access
+rules [[class.access]] are considered only once name lookup and function
 overload resolution (if applicable) have succeeded. Only after name
 lookup, function overload resolution (if applicable) and access checking
+have succeeded are the semantic properties introduced by the name’s
+declaration and its reachable [[module.reach]] redeclarations used
+further in expression processing [[expr]].
+A name “looked up in the context of an expression” is looked up in the
+scope where the expression is found.
+The injected-class-name of a class [[class.pre]] is also considered to
+be a member of that class for the purposes of name hiding and lookup.
 [*Note 1*:  [[basic.link]] discusses linkage issues. The notions of
 scope, point of declaration and name hiding are discussed in
 [[basic.scope]]. — *end note*]
 [*Note 1*:
 For purposes of determining (during parsing) whether an expression is a
 *postfix-expression* for a function call, the usual name lookup rules
+apply. In some cases a name followed by `<` is treated as a
+*template-name* even though name lookup did not find a *template-name*
+(see [[temp.names]]). For example,
+``` cpp
+int h;
+void g();
+namespace N {
+  struct A {};
+  template <class T> int f(T);
+  template <class T> int g(T);
+  template <class T> int h(T);
+}
+int x = f<N::A>(N::A());        // OK: lookup of f finds nothing, f treated as template name
+int y = g<N::A>(N::A());        // OK: lookup of g finds a function, g treated as template name
+int z = h<N::A>(N::A());        // error: h< does not begin a template-id
+```
+The rules in  [[basic.lookup.argdep]] have no effect on the syntactic
+interpretation of an expression. For example,
 ``` cpp
 typedef int f;
 namespace N {
   struct A {
   };
 }
 ```
 Because the expression is not a function call, the argument-dependent
+name lookup [[basic.lookup.argdep]] does not apply and the friend
 function `f` is not found.
 — *end note*]
 A name used in global scope, outside of any function, class or
 A name used in a user-declared namespace outside of the definition of
 any function or class shall be declared before its use in that namespace
 or before its use in a namespace enclosing its namespace.
 In the definition of a function that is a member of namespace `N`, a
+name used after the function’s *declarator-id*[^3] shall be declared
 before its use in the block in which it is used or in one of its
+enclosing blocks [[stmt.block]] or shall be declared before its use in
+namespace `N` or, if `N` is a nested namespace, shall be declared before
+its use in one of `N`’s enclosing namespaces.
 [*Example 1*:
 ``` cpp
 namespace A {
 }
 ```
 — *end example*]
+A name used in the definition of a class `X` [^4] outside of a
+complete-class context [[class.mem]] of `X` shall be declared in one of
+the following ways:
+- before its use in class `X` or be a member of a base class of `X`
+  [[class.member.lookup]], or
+- if `X` is a nested class of class `Y` [[class.nest]], before the
   definition of `X` in `Y`, or shall be a member of a base class of `Y`
   (this lookup applies in turn to `Y`’s enclosing classes, starting with
+  the innermost enclosing class),[^5] or
+- if `X` is a local class [[class.local]] or is a nested class of a
   local class, before the definition of class `X` in a block enclosing
   the definition of class `X`, or
 - if `X` is a member of namespace `N`, or is a nested class of a class
   that is a member of `N`, or is a local class or a nested class within
   a local class of a function that is a member of `N`, before the
 ```
 — *end example*]
 [*Note 2*: When looking for a prior declaration of a class or function
+introduced by a friend declaration, scopes outside of the innermost
 enclosing namespace scope are not considered; see
 [[namespace.memdef]]. — *end note*]
 [*Note 3*:  [[basic.scope.class]] further describes the restrictions on
 the use of names in a class definition. [[class.nest]] further describes
 the restrictions on the use of names in nested class definitions.
 [[class.local]] further describes the restrictions on the use of names
 in local class definitions. — *end note*]
+For the members of a class `X`, a name used in a complete-class context
+[[class.mem]] of `X` or in the definition of a class member outside of
+the definition of `X`, following the member’s *declarator-id*[^6], shall
+be declared in one of the following ways:
 - before its use in the block in which it is used or in an enclosing
+  block [[stmt.block]], or
+- shall be a member of class `X` or be a member of a base class of `X`
+  [[class.member.lookup]], or
+- if `X` is a nested class of class `Y` [[class.nest]], shall be a
   member of `Y`, or shall be a member of a base class of `Y` (this
   lookup applies in turn to `Y`’s enclosing classes, starting with the
+  innermost enclosing class),[^7] or
+- if `X` is a local class [[class.local]] or is a nested class of a
   local class, before the definition of class `X` in a block enclosing
   the definition of class `X`, or
 - if `X` is a member of namespace `N`, or is a nested class of a class
   that is a member of `N`, or is a local class or a nested class within
   a local class of a function that is a member of `N`, before the use of
 [[class.nest]] further describes the restrictions on the use of names in
 the scope of nested classes. [[class.local]] further describes the
 restrictions on the use of names in local class
 definitions. — *end note*]
+Name lookup for a name used in the definition of a friend function
+[[class.friend]] defined inline in the class granting friendship shall
 proceed as described for lookup in member function definitions. If the
+friend function is not defined in the class granting friendship, name
+lookup in the friend function definition shall proceed as described for
+lookup in namespace member function definitions.
+In a friend declaration naming a member function, a name used in the
 function declarator and not part of a *template-argument* in the
 *declarator-id* is first looked up in the scope of the member function’s
+class [[class.member.lookup]]. If it is not found, or if the name is
 part of a *template-argument* in the *declarator-id*, the look up is as
 described for unqualified names in the definition of the class granting
 friendship.
 [*Example 4*:
 };
 ```
 — *end example*]
+During the lookup for a name used as a default argument
+[[dcl.fct.default]] in a function *parameter-declaration-clause* or used
+in the *expression* of a *mem-initializer* for a constructor
+[[class.base.init]], the function parameter names are visible and hide
 the names of entities declared in the block, class or namespace scopes
 containing the function declaration.
 [*Note 5*:  [[dcl.fct.default]] further describes the restrictions on
 the use of names in default arguments. [[class.base.init]] further
 During the lookup of a name used in the *constant-expression* of an
 *enumerator-definition*, previously declared *enumerator*s of the
 enumeration are visible and hide the names of entities declared in the
 block, class, or namespace scopes containing the *enum-specifier*.
+A name used in the definition of a `static` data member of class `X`
+[[class.static.data]] (after the *qualified-id* of the static member) is
+looked up as if the name was used in a member function of `X`.
 [*Note 6*:  [[class.static.data]] further describes the restrictions on
 the use of names in the definition of a `static` data
 member. — *end note*]
 int N::j = i;       // N::j == 4
 ```
 — *end example*]
+A name used in the handler for a *function-try-block* [[except.pre]] is
+looked up as if the name was used in the outermost block of the function
+definition. In particular, the function parameter names shall not be
+redeclared in the *exception-declaration* nor in the outermost block of
+a handler for the *function-try-block*. Names declared in the outermost
+block of the function definition are not found when looked up in the
+scope of a handler for the *function-try-block*.
 [*Note 7*: But function parameter names are found. — *end note*]
 [*Note 8*: The rules for name lookup in template definitions are
 described in  [[temp.res]]. — *end note*]
 ### Argument-dependent name lookup <a id="basic.lookup.argdep">[[basic.lookup.argdep]]</a>
+When the *postfix-expression* in a function call [[expr.call]] is an
 *unqualified-id*, other namespaces not considered during the usual
+unqualified lookup [[basic.lookup.unqual]] may be searched, and in those
+namespaces, namespace-scope friend function or function template
+declarations [[class.friend]] not otherwise visible may be found. These
+modifications to the search depend on the types of the arguments (and
+for template template arguments, the namespace of the template
 argument).
 [*Example 1*:
 ``` cpp
 — *end example*]
 For each argument type `T` in the function call, there is a set of zero
 or more *associated namespaces* and a set of zero or more *associated
+entities* (other than namespaces) to be considered. The sets of
+namespaces and entities are determined entirely by the types of the
+function arguments (and the namespace of any template template
+argument). Typedef names and *using-declaration*s used to specify the
+types do not contribute to this set. The sets of namespaces and entities
+are determined in the following way:
 - If `T` is a fundamental type, its associated sets of namespaces and
+ entities are both empty.
+- If `T` is a class type (including unions), its associated entities
+ are: the class itself; the class of which it is a member, if any; and
+ its direct and indirect base classes. Its associated namespaces are
+ the innermost enclosing namespaces of its associated entities.
+ Furthermore, if `T` is a class template specialization, its associated
+ namespaces and entities also include: the namespaces and entities
+ associated with the types of the template arguments provided for
+ template type parameters (excluding template template parameters); the
+ templates used as template template arguments; the namespaces of which
+  any template template arguments are members; and the classes of which
+ any member templates used as template template arguments are members.
+ \[*Note 1*: Non-type template arguments do not contribute to the set
+  of associated namespaces. — *end note*]
 - If `T` is an enumeration type, its associated namespace is the
+  innermost enclosing namespace of its declaration, and its associated
+ entities are `T` and, if it is a class member, the member’s class.
 - If `T` is a pointer to `U` or an array of `U`, its associated
+  namespaces and entities are those associated with `U`.
+- If `T` is a function type, its associated namespaces and entities are
   those associated with the function parameter types and those
   associated with the return type.
 - If `T` is a pointer to a member function of a class `X`, its
+  associated namespaces and entities are those associated with the
   function parameter types and return type, together with those
   associated with `X`.
 - If `T` is a pointer to a data member of class `X`, its associated
+  namespaces and entities are those associated with the member type
   together with those associated with `X`.
+If an associated namespace is an inline namespace [[namespace.def]], its
+enclosing namespace is also included in the set. If an associated
 namespace directly contains inline namespaces, those inline namespaces
 are also included in the set. In addition, if the argument is the name
+or address of an overload set, its associated entities and namespaces
+are the union of those associated with each of the members of the set,
+i.e., the entities and namespaces associated with its parameter types
+and return type. Additionally, if the aforementioned overload set is
+named with a *template-id*, its associated entities and namespaces also
+include those of its type *template-argument*s and its template
+*template-argument*s.
+Let *X* be the lookup set produced by unqualified lookup
+[[basic.lookup.unqual]] and let *Y* be the lookup set produced by
 argument dependent lookup (defined as follows). If *X* contains
 - a declaration of a class member, or
 - a block-scope function declaration that is not a *using-declaration*,
   or
 then *Y* is empty. Otherwise *Y* is the set of declarations found in the
 namespaces associated with the argument types as described below. The
 set of declarations found by the lookup of the name is the union of *X*
 and *Y*.
+[*Note 2*: The namespaces and entities associated with the argument
+types can include namespaces and entities already considered by the
 ordinary unqualified lookup. — *end note*]
 [*Example 2*:
 ``` cpp
 }
 ```
 — *end example*]
+When considering an associated namespace `N`, the lookup is the same as
+the lookup performed when `N` is used as a qualifier [[namespace.qual]]
+except that:
+- Any *using-directive*s in `N` are ignored.
 - All names except those of (possibly overloaded) functions and function
   templates are ignored.
+- Any namespace-scope friend functions or friend function templates
+  [[class.friend]] declared in classes with reachable definitions in the
+  set of associated entities are visible within their respective
+  namespaces even if they are not visible during an ordinary lookup
+  [[namespace.memdef]].
+- Any exported declaration `D` in `N` declared within the purview of a
+  named module `M` [[module.interface]] is visible if there is an
+  associated entity attached to `M` with the same innermost enclosing
+  non-inline namespace as `D`.
+- If the lookup is for a dependent name ([[temp.dep]],
+  [[temp.dep.candidate]]), any declaration `D` in `N` is visible if `D`
+  would be visible to qualified name lookup [[namespace.qual]] at any
+  point in the instantiation context [[module.context]] of the lookup,
+  unless `D` is declared in another translation unit, attached to the
+  global module, and is either discarded [[module.global.frag]] or has
+  internal linkage.
+[*Example 3*:
+Translation unit #1
+``` cpp
+export module M;
+namespace R {
+  export struct X {};
+  export void f(X);
+}
+namespace S {
+  export void f(R::X, R::X);
+}
+```
+Translation unit #2
+``` cpp
+export module N;
+import M;
+export R::X make();
+namespace R { static int g(X); }
+export template<typename T, typename U> void apply(T t, U u) {
+  f(t, u);
+  g(t);
+}
+```
+Translation unit #3
+``` cpp
+module Q;
+import N;
+namespace S {
+  struct Z { template<typename T> operator T(); };
+}
+void test() {
+  auto x = make();              // OK, decltype(x) is R::X in module M
+  R::f(x);                      // error: R and R::f are not visible here
+  f(x);                         // OK, calls R::f from interface of M
+  f(x, S::Z());                 // error: S::f in module M not considered
+                                // even though S is an associated namespace
+  apply(x, S::Z());             // error: S::f is visible in instantiation context, but
+                                // R::g has internal linkage and cannot be used outside TU #2
+}
+```
+— *end example*]
 ### Qualified name lookup <a id="basic.lookup.qual">[[basic.lookup.qual]]</a>
 The name of a class or namespace member or enumerator can be referred to
+after the `::` scope resolution operator [[expr.prim.id.qual]] applied
+to a *nested-name-specifier* that denotes its class, namespace, or
 enumeration. If a `::` scope resolution operator in a
 *nested-name-specifier* is not preceded by a *decltype-specifier*,
 lookup of the name preceding that `::` considers only namespaces, types,
 and templates whose specializations are types. If the name found does
 not designate a namespace or a class, enumeration, or dependent type,
   static int n;
 };
 int main() {
   int A;
   A::n = 42;        // OK
+  A b;              // error: A does not name a type
 }
 ```
 — *end example*]
 [*Note 1*: Multiply qualified names, such as `N1::N2::N3::n`, can be
+used to refer to members of nested classes [[class.nest]] or members of
+nested namespaces. — *end note*]
 In a declaration in which the *declarator-id* is a *qualified-id*, names
 used before the *qualified-id* being declared are looked up in the
 defining namespace scope; names following the *qualified-id* are looked
 up in the scope of the member’s class or namespace.
 class C {
   class X { };
   static const int number = 50;
   static X arr[number];
 };
+X C::arr[number];   // error:
                     // equivalent to ::X C::arr[C::number];
                     // and not to C::X C::arr[C::number];
 ```
 — *end example*]
+A name prefixed by the unary scope operator `::` [[expr.prim.id.qual]]
+is looked up in global scope, in the translation unit where it is used.
+The name shall be declared in global namespace scope or shall be a name
 whose declaration is visible in global scope because of a
+*using-directive* [[namespace.qual]]. The use of `::` allows a global
+name to be referred to even if its identifier has been hidden
+[[basic.scope.hiding]].
 A name prefixed by a *nested-name-specifier* that nominates an
 enumeration type shall represent an *enumerator* of that enumeration.
+In a *qualified-id* of the form:
 ``` bnf
+nested-name-specifierₒₚₜ type-name '::' '~' type-name
 ```
+the second *type-name* is looked up in the same scope as the first.
 [*Example 3*:
 ``` cpp
 struct C {
 #### Class members <a id="class.qual">[[class.qual]]</a>
 If the *nested-name-specifier* of a *qualified-id* nominates a class,
 the name specified after the *nested-name-specifier* is looked up in the
+scope of the class [[class.member.lookup]], except for the cases listed
+below. The name shall represent one or more members of that class or of
+one of its base classes [[class.derived]].
 [*Note 1*: A class member can be referred to using a *qualified-id* at
+any point in its potential scope [[basic.scope.class]]. — *end note*]
 The exceptions to the name lookup rule above are the following:
 - the lookup for a destructor is as specified in  [[basic.lookup.qual]];
 - a *conversion-type-id* of a *conversion-function-id* is looked up in
   the same manner as a *conversion-type-id* in a class member access
   (see  [[basic.lookup.classref]]);
 - the names in a *template-argument* of a *template-id* are looked up in
+  the context in which the entire *postfix-expression* occurs;
+- the lookup for a name specified in a *using-declaration*
+  [[namespace.udecl]] also finds class or enumeration names hidden
+  within the same scope [[basic.scope.hiding]].
+In a lookup in which function names are not ignored[^8] and the
 *nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
+  up in `C`, is the injected-class-name of `C` [[class.pre]], or
+- in a *using-declarator* of a *using-declaration* [[namespace.udecl]]
+  that is a *member-declaration*, if the name specified after the
+  *nested-name-specifier* is the same as the *identifier* or the
+  *simple-template-id*’s *template-name* in the last component of the
+  *nested-name-specifier*,
 the name is instead considered to name the constructor of class `C`.
 [*Note 2*: For example, the constructor is not an acceptable lookup
 result in an *elaborated-type-specifier* so the constructor would not be
 A::A() { }
 B::B() { }
 B::A ba;            // object of type A
+A::A a;             // error: A::A is not a type name
 struct A::A a2;     // object of type A
 ```
 — *end example*]
 names in a *template-argument* of a *template-id* are looked up in the
 context in which the entire *postfix-expression* occurs.
 For a namespace `X` and name `m`, the namespace-qualified lookup set
 S(X, m) is defined as follows: Let S'(X, m) be the set of all
+declarations of `m` in `X` and the inline namespace set of `X`
+[[namespace.def]] whose potential scope [[basic.scope.namespace]] would
+include the namespace in which `m` is declared at the location of the
+*nested-name-specifier*. If S'(X, m) is not empty, S(X, m) is S'(X, m);
 otherwise, S(X, m) is the union of S(Nᵢ, m) for all namespaces Nᵢ
 nominated by *using-directive*s in `X` and its inline namespace set.
 Given `X::m` (where `X` is a user-declared namespace), or given `::m`
 (where X is the global namespace), if S(X, m) is the empty set, the
 program is ill-formed. Otherwise, if S(X, m) has exactly one member, or
+if the context of the reference is a *using-declaration*
+[[namespace.udecl]], S(X, m) is the required set of declarations of `m`.
+Otherwise if the use of `m` is not one that allows a unique declaration
+to be chosen from S(X, m), the program is ill-formed.
 [*Example 1*:
 ``` cpp
 int x;
 — *end example*]
 During the lookup of a qualified namespace member name, if the lookup
 finds more than one declaration of the member, and if one declaration
 introduces a class name or enumeration name and the other declarations
+introduce either the same variable, the same enumerator, or a set of
 functions, the non-type name hides the class or enumeration name if and
 only if the declarations are from the same namespace; otherwise (the
 declarations are from different namespaces), the program is ill-formed.
 [*Example 4*:
 ``` bnf
 nested-name-specifier unqualified-id
 ```
 the *unqualified-id* shall name a member of the namespace designated by
+the *nested-name-specifier* or of an element of the inline namespace set
+[[namespace.def]] of that namespace.
 [*Example 5*:
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
   using namespace B;
 }
+void A::f1(int){ }  // error: f1 is not a member of A
 ```
 — *end example*]
 However, in such namespace member declarations, the
 — *end example*]
 ### Elaborated type specifiers <a id="basic.lookup.elab">[[basic.lookup.elab]]</a>
+An *elaborated-type-specifier* [[dcl.type.elab]] may be used to refer to
+a previously declared *class-name* or *enum-name* even though the name
+has been hidden by a non-type declaration [[basic.scope.hiding]].
 If the *elaborated-type-specifier* has no *nested-name-specifier*, and
 unless the *elaborated-type-specifier* appears in a declaration with the
 following form:
 [*Example 1*:
 ``` cpp
 struct Node {
+  struct Node* Next;            // OK: Refers to injected-class-name Node
+  struct Data* Data;            // OK: Declares type Data at global scope and member Data
 };
 struct Data {
   struct Node* Node;            // OK: Refers to Node at global scope
+  friend struct ::Glob;         // error: Glob is not declared, cannot introduce a qualified type[dcl.type.elab]
   friend struct Glob;           // OK: Refers to (as yet) undeclared Glob at global scope.
   ...
 };
 struct Base {
   friend class Data;            // OK: nested Data is a friend
   struct Data { ... };    // Defines nested Data
 };
 struct Data;                    // OK: Redeclares Data at global scope
+struct ::Data;                  // error: cannot introduce a qualified type[dcl.type.elab]
+struct Base::Data;              // error: cannot introduce a qualified type[dcl.type.elab]
 struct Base::Datum;             // error: Datum undefined
 struct Base::Data* pBase;       // OK: refers to nested Data
 ```
 — *end example*]
 ### Class member access <a id="basic.lookup.classref">[[basic.lookup.classref]]</a>
+In a class member access expression [[expr.ref]], if the `.` or `->`
 token is immediately followed by an *identifier* followed by a `<`, the
 identifier must be looked up to determine whether the `<` is the
+beginning of a template argument list [[temp.names]] or a less-than
 operator. The identifier is first looked up in the class of the object
+expression [[class.member.lookup]]. If the identifier is not found, it
+is then looked up in the context of the entire *postfix-expression* and
+shall name a template whose specializations are types.
+If the *id-expression* in a class member access [[expr.ref]] is an
 *unqualified-id*, and the type of the object expression is of a class
+type `C`, the *unqualified-id* is looked up in the scope of class `C`
+[[class.member.lookup]].
 If the *unqualified-id* is `~`*type-name*, the *type-name* is looked up
 in the context of the entire *postfix-expression*. If the type `T` of
 the object expression is of a class type `C`, the *type-name* is also
 looked up in the scope of class `C`. At least one of the lookups shall
 ``` cpp
 class-name-or-namespace-name::...
 ```
+the `class-name-or-namespace-name` following the `.` or `->` operator is
+first looked up in the class of the object expression
+[[class.member.lookup]] and the name, if found, is used. Otherwise it is
+looked up in the context of the entire *postfix-expression*.
 [*Note 1*: See  [[basic.lookup.qual]], which describes the lookup of a
 name before `::`, which will only find a type or namespace
 name. — *end note*]
 ``` cpp
 ::class-name-or-namespace-name::...
 ```
+the `class-name-or-namespace-name` is looked up in global scope as a
 *class-name* or *namespace-name*.
+If the *nested-name-specifier* contains a *simple-template-id*
+[[temp.names]], the names in its *template-argument*s are looked up in
 the context in which the entire *postfix-expression* occurs.
 If the *id-expression* is a *conversion-function-id*, its
 *conversion-type-id* is first looked up in the class of the object
+expression [[class.member.lookup]] and the name, if found, is used.
+Otherwise it is looked up in the context of the entire
+*postfix-expression*. In each of these lookups, only names that denote
+types or templates whose specializations are types are considered.
 [*Example 2*:
 ``` cpp
 struct A { };

Diff to HTML by rtfpessoa