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

Files changed (1) hide show

tmp/tmpta2g_lti/{from.md → to.md} +687 -728

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

@@ -1,50 +1,462 @@
 ## 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*]
 ### Unqualified name lookup <a id="basic.lookup.unqual">[[basic.lookup.unqual]]</a>
-In all the cases listed in  [[basic.lookup.unqual]], the scopes are
-searched for a declaration in the order listed in each of the respective
-categories; name lookup ends as soon as a declaration is found for the
-name. If no declaration is found, the program is ill-formed.
-The declarations from the namespace nominated by a *using-directive*
-become visible in a namespace enclosing the *using-directive*; see
-[[namespace.udir]]. For the purpose of the unqualified name lookup rules
-described in  [[basic.lookup.unqual]], the declarations from the
-namespace nominated by the *using-directive* are considered members of
-that enclosing namespace.
-The lookup for an unqualified name used as the *postfix-expression* of a
-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
@@ -60,17 +472,17 @@ namespace N {
   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 {
@@ -81,398 +493,79 @@ 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
-user-declared namespace, shall be declared before its use in global
-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*[^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 {
-  namespace N {
-    void f();
-  }
-}
-void A::N::f() {
-  i = 5;
-  // The following scopes are searched for a declaration of i:
-  // 1) outermost block scope of A::N::f, before the use of i
-  // 2) scope of namespace N
-  // 3) scope of namespace A
-  // 4) global scope, before the definition of A::N::f
-}
-```
-— *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
-  definition of class `X` in namespace `N` or in one of `N`’s enclosing
-  namespaces.
-[*Example 2*:
-``` cpp
-namespace M {
-  class B { };
-}
-```
-``` cpp
-namespace N {
-  class Y : public M::B {
-    class X {
-      int a[i];
-    };
-  };
-}
-// The following scopes are searched for a declaration of i:
-// 1) scope of class N::Y::X, before the use of i
-// 2) scope of class N::Y, before the definition of N::Y::X
-// 3) scope of N::Y's base class M::B
-// 4) scope of namespace N, before the definition of N::Y
-// 5) global scope, before the definition of 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 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
-  the name, in namespace `N` or in one of `N`’s enclosing namespaces.
-[*Example 3*:
-``` cpp
-class B { };
-namespace M {
-  namespace N {
-    class X : public B {
-      void f();
-    };
-  }
-}
-void M::N::X::f() {
-  i = 16;
-}
-// The following scopes are searched for a declaration of i:
-// 1) outermost block scope of M::N::X::f, before the use of i
-// 2) scope of class M::N::X
-// 3) scope of M::N::X's base class B
-// 4) scope of namespace M::N
-// 5) scope of namespace M
-// 6) global scope, before the definition of M::N::X::f
-```
-— *end example*]
-[*Note 4*:  [[class.mfct]] and  [[class.static]] further describe the
-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*:
-``` cpp
-struct A {
-  typedef int AT;
-  void f1(AT);
-  void f2(float);
-  template <class T> void f3();
-};
-struct B {
-  typedef char AT;
-  typedef float BT;
-  friend void A::f1(AT);        // parameter type is A::AT
-  friend void A::f2(BT);        // parameter type is B::BT
-  friend void A::f3<AT>();      // template argument is B::AT
-};
-```
-— *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
-describes the restrictions on the use of names in a
-*ctor-initializer*. — *end note*]
-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*]
-If a variable member of a namespace is defined outside of the scope of
-its namespace then any name that appears in the definition of the member
-(after the *declarator-id*) is looked up as if the definition of the
-member occurred in its namespace.
-[*Example 5*:
-``` cpp
-namespace N {
-  int i = 4;
-  extern int j;
-}
-int i = 2;
-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
-namespace N {
-  struct S { };
-  void f(S);
-}
-void g() {
-  N::S s;
-  f(s);             // OK: calls N::f
-  (f)(s);           // error: N::f not considered; parentheses prevent argument-dependent lookup
-}
-```
-— *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
-- a declaration that is neither a function nor a function template
-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
-namespace NS {
-  class T { };
-  void f(T);
-  void g(T, int);
-}
-NS::T parm;
-void g(NS::T, float);
-int main() {
-  f(parm);                      // OK: calls NS::f
-  extern void g(NS::T, float);
-  g(parm, 1);                   // OK: calls g(NS::T, float)
-}
-```
-— *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 {
@@ -516,21 +609,42 @@ void test() {
 }
 ```
 — *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,
-the program is ill-formed.
 [*Example 1*:
 ``` cpp
 class A {
@@ -540,70 +654,137 @@ public:
 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.
 [*Example 2*:
 ``` cpp
-class X { };
-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 {
   typedef int I;
 };
 typedef int I1, I2;
 extern int* p;
 extern int* q;
   p->C::I::~I();        // I is looked up in the scope of C
-q->I1::~I2(); // I2 is looked up in the scope of the postfix-expression
 struct A {
   ~A();
 };
 typedef A AB;
 int main() {
@@ -612,55 +793,22 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 2*:  [[basic.lookup.classref]] describes how name lookup
-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 [[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
-used in place of the injected-class-name. — *end note*]
-Such a constructor name shall be used only in the *declarator-id* of a
-declaration that names a constructor or in a *using-declaration*.
 [*Example 1*:
 ``` cpp
 struct A { A(); };
@@ -674,39 +822,21 @@ A::A a;             // error: A::A is not a type name
 struct A::A a2;     // object of type A
 ```
 — *end example*]
-A class member name hidden by a name in a nested declarative region or
-by the name of a derived class member can still be found if qualified by
-the name of its class followed by the `::` operator.
 #### Namespace members <a id="namespace.qual">[[namespace.qual]]</a>
-If the *nested-name-specifier* of a *qualified-id* nominates a namespace
-(including the case where the *nested-name-specifier* is `::`, i.e.,
-nominating the global namespace), the name specified after the
-*nested-name-specifier* is looked up in the scope of the namespace. 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]] 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;
@@ -760,11 +890,11 @@ void h()
 }
 ```
 — *end example*]
-[*Note 1*:
 The same declaration found more than once is not an ambiguity (because
 it is still a unique declaration).
 [*Example 2*:
@@ -787,11 +917,11 @@ namespace BC {
   using namespace C;
 }
 void f()
 {
-  BC::a++;          // OK: S is { `A::a`, `A::a` }
 }
 namespace D {
   using A::a;
 }
@@ -801,11 +931,11 @@ namespace BD {
   using namespace D;
 }
 void g()
 {
-  BD::a++;          // OK: S is { `A::a`, `A::a` }
 }
 ```
 — *end example*]
@@ -830,26 +960,21 @@ namespace B {
   using namespace A;
 }
 void f()
 {
-  A::a++;           // OK: a declared directly in A, S is { `A::a` }
-  B::a++;           // OK: both A and B searched (once), S is { `A::a` }
-  A::b++;           // OK: both A and B searched (once), S is { `B::b` }
-  B::b++;           // OK: b declared directly in B, S is { `B::b` }
 }
 ```
 — *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*:
 ``` cpp
 namespace A {
@@ -870,221 +995,55 @@ namespace C {
 }
 ```
 — *end example*]
-In a declaration for a namespace member in which the *declarator-id* is
-a *qualified-id*, given that the *qualified-id* for the namespace member
-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){ }  // error: f1 is not a member of A
-```
-— *end example*]
-However, in such namespace member declarations, the
-*nested-name-specifier* may rely on *using-directive*s to implicitly
-provide the initial part of the *nested-name-specifier*.
-[*Example 6*:
-``` cpp
-namespace A {
-  namespace B {
-    void f1(int);
-  }
-}
-namespace C {
-  namespace D {
-    void f1(int);
-  }
-}
-using namespace A;
-using namespace C::D;
-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:
-``` bnf
-class-key attribute-specifier-seqₒₚₜ identifier ';'
-```
-the *identifier* is looked up according to  [[basic.lookup.unqual]] but
-ignoring any non-type names that have been declared. If the
-*elaborated-type-specifier* is introduced by the `enum` keyword and this
-lookup does not find a previously declared *type-name*, the
-*elaborated-type-specifier* is ill-formed. If the
-*elaborated-type-specifier* is introduced by the *class-key* and this
-lookup does not find a previously declared *type-name*, or if the
-*elaborated-type-specifier* appears in a declaration with the form:
-``` bnf
-class-key attribute-specifier-seqₒₚₜ identifier ';'
-```
-the *elaborated-type-specifier* is a declaration that introduces the
-*class-name* as described in  [[basic.scope.pdecl]].
-If the *elaborated-type-specifier* has a *nested-name-specifier*,
-qualified name lookup is performed, as described in
-[[basic.lookup.qual]], but ignoring any non-type names that have been
-declared. If the name lookup does not find a previously declared
-*type-name*, the *elaborated-type-specifier* is ill-formed.
 [*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 {
-  struct Data;                  // OK: Declares nested Data
-  struct ::Data*     thatData;  // OK: Refers to ::Data
-  struct Base::Data* thisData;  // OK: Refers to nested Data
-  friend class ::Data;          // OK: global Data is a friend
-  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
-find a name that refers to cv `T`.
-[*Example 1*:
-``` cpp
-struct A { };
-struct B {
-  struct A { };
-  void f(::A* a);
-};
-void B::f(::A* a) {
-  a->~A();                      // OK: lookup in *a finds the injected-class-name
-}
-```
-— *end example*]
-If the *id-expression* in a class member access is a *qualified-id* of
-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
-[[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*]
-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 [[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 { };
-namespace N {
-  struct A {
-    void g() { }
-    template <class T> operator T();
-  };
-}
-int main() {
-  N::A a;
-  a.operator A();               // calls N::A::operator N::A
-}
 ```
 — *end example*]
 ### Using-directives and namespace aliases <a id="basic.lookup.udir">[[basic.lookup.udir]]</a>

 ## Name lookup <a id="basic.lookup">[[basic.lookup]]</a>
+### General <a id="basic.lookup.general">[[basic.lookup.general]]</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.
+Unless otherwise specified, the program is ill-formed if no declarations
+are found. If the declarations found by name lookup all denote functions
+or function templates, the declarations are said to form an *overload
+set*. Otherwise, if the declarations found by name lookup do not all
+denote the same entity, they are *ambiguous* and the program is
+ill-formed. 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 declarations used in
+further processing.
+A program point P is said to follow any declaration in the same
+translation unit whose locus [[basic.scope.pdecl]] is before P.
+[*Note 1*: The declaration might appear in a scope that does not
+contain P. — *end note*]
+A declaration X *precedes* a program point P in a translation unit L if
+P follows X, X inhabits a class scope and is reachable from P, or else X
+appears in a translation unit D and
+- P follows a *module-import-declaration* or *module-declaration* that
+  imports D (directly or indirectly), and
+- X appears after the *module-declaration* in D (if any) and before the
+  *private-module-fragment* in D (if any), and
+- either X is exported or else D and L are part of the same module and X
+  does not inhabit a namespace with internal linkage or declare a name
+  with internal linkage. \[*Note 2*: Names declared by a
+  *using-declaration* have no linkage. — *end note*]
+[*Note 3*:
+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 1*:
+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 *single search* in a scope S for a name N from a program point P finds
+all declarations that precede P to which any name that is the same as N
+[[basic.pre]] is bound in S. If any such declaration is a
+*using-declarator* whose terminal name [[expr.prim.id.unqual]] is not
+dependent [[temp.dep.type]], it is replaced by the declarations named by
+the *using-declarator* [[namespace.udecl]].
+In certain contexts, only certain kinds of declarations are included.
+After any such restriction, any declarations of classes or enumerations
+are discarded if any other declarations are found.
+[*Note 4*: A type (but not a *typedef-name* or template) is therefore
+hidden by any other entity in its scope. — *end note*]
+However, if a lookup is *type-only*, only declarations of types and
+templates whose specializations are types are considered; furthermore,
+if declarations of a *typedef-name* and of the type to which it refers
+are found, the declaration of the *typedef-name* is discarded instead of
+the type declaration.
+### Member name lookup <a id="class.member.lookup">[[class.member.lookup]]</a>
+A *search* in a scope X for a name M from a program point P is a single
+search in X for M from P unless X is the scope of a class or class
+template T, in which case the following steps define the result of the
+search.
+[*Note 1*: The result differs only if M is a *conversion-function-id*
+or if the single search would find nothing. — *end note*]
+The *lookup set* for a name N in a class or class template C, called
+S(N,C), consists of two component sets: the *declaration set*, a set of
+members named N; and the *subobject set*, a set of subobjects where
+declarations of these members were found (possibly via
+*using-declaration*s). In the declaration set, type declarations
+(including injected-class-names) are replaced by the types they
+designate. S(N,C) is calculated as follows:
+The declaration set is the result of a single search in the scope of C
+for N from immediately after the *class-specifier* of C if P is in a
+complete-class context of C or from P otherwise. If the resulting
+declaration set is not empty, the subobject set contains C itself, and
+calculation is complete.
+Otherwise (i.e., C does not contain a declaration of N or the resulting
+declaration set is empty), S(N,C) is initially empty. Calculate the
+lookup set for N in each direct non-dependent [[temp.dep.type]] base
+class subobject Bᵢ, and merge each such lookup set S(N,Bᵢ) in turn into
+S(N,C).
+[*Note 2*: If C is incomplete, only base classes whose *base-specifier*
+appears before P are considered. If C is an instantiated class, its base
+classes are not dependent. — *end note*]
+The following steps define the result of merging lookup set S(N,Bᵢ) into
+the intermediate S(N,C):
+- If each of the subobject members of S(N,Bᵢ) is a base class subobject
+  of at least one of the subobject members of S(N,C), or if S(N,Bᵢ) is
+  empty, S(N,C) is unchanged and the merge is complete. Conversely, if
+  each of the subobject members of S(N,C) is a base class subobject of
+  at least one of the subobject members of S(N,Bᵢ), or if S(N,C) is
+  empty, the new S(N,C) is a copy of S(N,Bᵢ).
+- Otherwise, if the declaration sets of S(N,Bᵢ) and S(N,C) differ, the
+  merge is ambiguous: the new S(N,C) is a lookup set with an invalid
+  declaration set and the union of the subobject sets. In subsequent
+  merges, an invalid declaration set is considered different from any
+  other.
+- Otherwise, the new S(N,C) is a lookup set with the shared set of
+  declarations and the union of the subobject sets.
+The result of the search is the declaration set of S(M,T). If it is an
+invalid set, the program is ill-formed. If it differs from the result of
+a search in T for M in a complete-class context [[class.mem]] of T, the
+program is ill-formed, no diagnostic required.
+[*Example 1*:
+``` cpp
+struct A { int x; };                    // S(x,A) = { { A::x }, { A } }
+struct B { float x; };                  // S(x,B) = { { B::x }, { B } }
+struct C: public A, public B { };       // S(x,C) = { invalid, { A in C, B in C } }
+struct D: public virtual C { };         // S(x,D) = S(x,C)
+struct E: public virtual C { char x; }; // S(x,E) = { { E::x }, { E } }
+struct F: public D, public E { };       // S(x,F) = S(x,E)
+int main() {
+  F f;
+  f.x = 0;                              // OK, lookup finds E::x
+}
+```
+S(`x`,`F`) is unambiguous because the `A` and `B` base class subobjects
+of `D` are also base class subobjects of `E`, so S(`x`,`D`) is discarded
+in the first merge step.
+— *end example*]
+If M is a non-dependent *conversion-function-id*, conversion function
+templates that are members of T are considered. For each such template
+F, the lookup set S(t,T) is constructed, considering a function template
+declaration to have the name t only if it corresponds to a declaration
+of F [[basic.scope.scope]]. The members of the declaration set of each
+such lookup set, which shall not be an invalid set, are included in the
+result.
+[*Note 3*: Overload resolution will discard those that cannot convert
+to the type specified by M [[temp.over]]. — *end note*]
+[*Note 4*: A static member, a nested type or an enumerator defined in a
+base class `T` can unambiguously be found even if an object has more
+than one base class subobject of type `T`. Two base class subobjects
+share the non-static member subobjects of their common virtual base
+classes. — *end note*]
+[*Example 2*:
+``` cpp
+struct V {
+  int v;
+};
+struct A {
+  int a;
+  static int s;
+  enum { e };
+};
+struct B : A, virtual V { };
+struct C : A, virtual V { };
+struct D : B, C { };
+void f(D* pd) {
+  pd->v++;          // OK, only one v (virtual)
+  pd->s++;          // OK, only one s (static)
+  int i = pd->e;    // OK, only one e (enumerator)
+  pd->a++;          // error: ambiguous: two a{s} in D
+}
+```
+— *end example*]
+[*Note 5*:  When virtual base classes are used, a hidden declaration
+can be reached along a path through the subobject lattice that does not
+pass through the hiding declaration. This is not an ambiguity. The
+identical use with non-virtual base classes is an ambiguity; in that
+case there is no unique instance of the name that hides all the
+others. — *end note*]
+[*Example 3*:
+``` cpp
+struct V { int f();  int x; };
+struct W { int g();  int y; };
+struct B : virtual V, W {
+  int f();  int x;
+  int g();  int y;
+};
+struct C : virtual V, W { };
+struct D : B, C { void glorp(); };
+```
+<a id="fig:class.lookup"></a>
+![Name lookup \[fig:class.lookup\]](images/figname.svg)
+As illustrated in Figure [[fig:class.lookup]], the names declared in
+`V` and the left-hand instance of `W` are hidden by those in `B`, but
+the names declared in the right-hand instance of `W` are not hidden at
+all.
+``` cpp
+void D::glorp() {
+  x++;              // OK, B::x hides V::x
+  f();              // OK, B::f() hides V::f()
+  y++;              // error: B::y and C's W::y
+  g();              // error: B::g() and C's W::g()
+}
+```
+— *end example*]
+An explicit or implicit conversion from a pointer to or an expression
+designating an object of a derived class to a pointer or reference to
+one of its base classes shall unambiguously refer to a unique object
+representing the base class.
+[*Example 4*:
+``` cpp
+struct V { };
+struct A { };
+struct B : A, virtual V { };
+struct C : A, virtual V { };
+struct D : B, C { };
+void g() {
+  D d;
+  B* pb = &d;
+  A* pa = &d;       // error: ambiguous: C's A or B's A?
+  V* pv = &d;       // OK, only one V subobject
+}
+```
+— *end example*]
+[*Note 6*: Even if the result of name lookup is unambiguous, use of a
+name found in multiple subobjects might still be ambiguous
+[[conv.mem]], [[expr.ref]], [[class.access.base]]. — *end note*]
+[*Example 5*:
+``` cpp
+struct B1 {
+  void f();
+  static void f(int);
+  int i;
+};
+struct B2 {
+  void f(double);
+};
+struct I1: B1 { };
+struct I2: B1 { };
+struct D: I1, I2, B2 {
+  using B1::f;
+  using B2::f;
+  void g() {
+    f();                        // Ambiguous conversion of this
+    f(0);                       // Unambiguous (static)
+    f(0.0);                     // Unambiguous (only one B2)
+    int B1::* mpB1 = &D::i;     // Unambiguous
+    int D::* mpD = &D::i;       // Ambiguous conversion
+  }
+};
+```
+— *end example*]
 ### Unqualified name lookup <a id="basic.lookup.unqual">[[basic.lookup.unqual]]</a>
+A *using-directive* is *active* in a scope S at a program point P if it
+precedes P and inhabits either S or the scope of a namespace nominated
+by a *using-directive* that is active in S at P.
+An *unqualified search* in a scope S from a program point P includes the
+results of searches from P in
+- S, and
+- for any scope U that contains P and is or is contained by S, each
+ namespace contained by S that is nominated by a *using-directive* that
+  is active in U at P.
+If no declarations are found, the results of the unqualified search are
+the results of an unqualified search in the parent scope of S, if any,
+from P.
+[*Note 1*: When a class scope is searched, the scopes of its base
+classes are also searched [[class.member.lookup]]. If it inherits from a
+single base, it is as if the scope of the base immediately contains the
+scope of the derived class. Template parameter scopes that are
+associated with one scope in the chain of parents are also considered
+[[temp.local]]. — *end note*]
+*Unqualified name lookup* from a program point performs an unqualified
+search in its immediate scope.
+An *unqualified name* is a name that does not immediately follow a
+*nested-name-specifier* or the `.` or `->` in a class member access
+expression [[expr.ref]], possibly after a `template` keyword or `~`.
+Unless otherwise specified, such a name undergoes unqualified name
+lookup from the point where it appears.
+An unqualified name that is a component name [[expr.prim.id.unqual]] of
+a *type-specifier* or *ptr-operator* of a *conversion-type-id* is looked
+up in the same fashion as the *conversion-function-id* in which it
+appears. If that lookup finds nothing, it undergoes unqualified name
+lookup; in each case, only names that denote types or templates whose
+specializations are types are considered.
+[*Example 1*:
+``` cpp
+struct T1 { struct U { int i; }; };
+struct T2 { };
+struct U1 {};
+struct U2 {};
+struct B {
+  using T = T1;
+  using U = U1;
+  operator U1 T1::*();
+  operator U1 T2::*();
+  operator U2 T1::*();
+  operator U2 T2::*();
+};
+template<class X, class T>
+int g() {
+  using U = U2;
+  X().operator U T::*();                // #1, searches for T in the scope of X first
+  X().operator U decltype(T())::*();    // #2
+  return 0;
+}
+int x = g<B, T2>();                     // #1 calls B::operator U1 T1::*
+                                        // #2 calls B::operator U1 T2::*
+```
+— *end example*]
+In a friend declaration *declarator* whose *declarator-id* is a
+*qualified-id* whose lookup context [[basic.lookup.qual]] is a class or
+namespace S, lookup for an unqualified name that appears after the
+*declarator-id* performs a search in the scope associated with S. If
+that lookup finds nothing, it undergoes unqualified name lookup.
+[*Example 2*:
+``` cpp
+using I = int;
+using D = double;
+namespace A {
+  inline namespace N {using C = char; }
+  using F = float;
+  void f(I);
+  void f(D);
+  void f(C);
+  void f(F);
+}
+struct X0 {using F = float; };
+struct W {
+  using D = void;
+  struct X : X0 {
+    void g(I);
+    void g(::D);
+    void g(F);
+  };
+};
+namespace B {
+  typedef short I, F;
+  class Y {
+    friend void A::f(I);        // error: no void A::f(short)
+    friend void A::f(D);        // OK
+    friend void A::f(C);        // error: A::N::C not found
+    friend void A::f(F);        // OK
+    friend void W::X::g(I);     // error: no void X::g(short)
+    friend void W::X::g(D);     // OK
+    friend void W::X::g(F);     // OK
+  };
+}
+```
+— *end example*]
+### 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*, and unqualified lookup [[basic.lookup.unqual]] for the
+name in the *unqualified-id* does not find any
+- declaration of a class member, or
+- function declaration inhabiting a block scope, or
+- declaration not of a function or function template
+then lookup for the name also includes the result of
+*argument-dependent lookup* in a set of associated namespaces that
+depends on the types of the arguments (and for template template
+arguments, the namespace of the template argument), as specified below.
+[*Example 1*:
+``` cpp
+namespace N {
+  struct S { };
+  void f(S);
+}
+void g() {
+  N::S s;
+  f(s);             // OK, calls N::f
+  (f)(s);           // error: N::f not considered; parentheses prevent argument-dependent lookup
+}
+```
+— *end example*]
 [*Note 1*:
 For purposes of determining (during parsing) whether an expression is a
 *postfix-expression* for a function call, the usual name lookup rules
   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 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, argument-dependent name
+lookup does not apply and the friend function `f` is not found.
 — *end note*]
 For each argument type `T` in the function call, there is a set of zero
+or more *associated entities* to be considered. The set of entities is
+determined entirely by the types of the function arguments (and any
+template template arguments). Any *typedef-name*s and
+*using-declaration*s used to specify the types do not contribute to this
+set. The set of entities is determined in the following way:
+- If `T` is a fundamental type, its associated set of entities is 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. Furthermore, if `T` is a class
+ template specialization, its associated entities also include: the
+ entities associated with the types of the template arguments provided
+ for template type parameters; the templates used as template template
+ arguments; and the classes of which any member templates used as
+  template template arguments are members. \[*Note 2*: Non-type template
+ arguments do not contribute to the set of associated
+ entities. — *end note*]
+- If `T` is an enumeration type, 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 entities
+  are those associated with `U`.
+- If `T` is a function type, its associated 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 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
+  entities are those associated with the member type together with those
+  associated with `X`.
+In addition, if the argument is an overload set or the address of such a
+set, its associated entities are the union of those associated with each
+of the members of the set, i.e., the entities associated with its
+parameter types and return type. Additionally, if the aforementioned
+overload set is named with a *template-id*, its associated entities also
+include its template *template-argument*s and those associated with its
+type *template-argument*s.
+The *associated namespaces* for a call are the innermost enclosing
+non-inline namespaces for its associated entities as well as every
+element of the inline namespace set [[namespace.def]] of those
+namespaces. Argument-dependent lookup finds all declarations of
+functions and function templates that
+- are found by a search of any associated namespace, or
+- are declared as a friend [[class.friend]] of any class with a
+ reachable definition in the set of associated entities, or
+- are exported, are attached to a named module `M` [[module.interface]],
+  do not appear in the translation unit containing the point of the
+  lookup, and have the same innermost enclosing non-inline namespace
+  scope as a declaration of an associated entity attached to `M`
+  [[basic.link]].
+If the lookup is for a dependent name
+[[temp.dep]], [[temp.dep.candidate]], the above lookup is also performed
+from each point in the instantiation context [[module.context]] of the
+lookup, additionally ignoring any declaration that appears in another
+translation unit, is attached to the global module, and is either
+discarded [[module.global.frag]] or has internal linkage.
 [*Example 2*:
 Translation unit #1
 ``` cpp
 export module M;
 namespace R {
 }
 ```
 — *end example*]
+[*Note 3*: The associated namespace can include namespaces already
+considered by ordinary unqualified lookup. — *end note*]
+[*Example 3*:
+``` cpp
+namespace NS {
+  class T { };
+  void f(T);
+  void g(T, int);
+}
+NS::T parm;
+void g(NS::T, float);
+int main() {
+  f(parm);                      // OK, calls NS::f
+  extern void g(NS::T, float);
+  g(parm, 1);                   // OK, calls g(NS::T, float)
+}
+```
+— *end example*]
 ### Qualified name lookup <a id="basic.lookup.qual">[[basic.lookup.qual]]</a>
+#### General <a id="basic.lookup.qual.general">[[basic.lookup.qual.general]]</a>
+Lookup of an *identifier* followed by a `::` scope resolution operator
+considers only namespaces, types, and templates whose specializations
+are types. If a name, *template-id*, or *decltype-specifier* is followed
+by a `::`, it shall designate a namespace, class, enumeration, or
+dependent type, and the `::` is never interpreted as a complete
+*nested-name-specifier*.
 [*Example 1*:
 ``` cpp
 class A {
 int main() {
   int A;
   A::n = 42;            // OK
   A b;                  // error: A does not name a type
 }
+template<int> struct B : A {};
+namespace N {
+  template<int> void B();
+  int f() {
+    return B<0>::n;     // error: N::B<0> is not a type
+  }
+}
 ```
 — *end example*]
+A member-qualified name is the (unique) component name
+[[expr.prim.id.unqual]], if any, of
+- an *unqualified-id* or
+- a *nested-name-specifier* of the form *type-name* `::` or
+ *namespace-name* `::`
+in the *id-expression* of a class member access expression [[expr.ref]].
+A *qualified name* is
+- a member-qualified name or
+- the terminal name of
+  - a *qualified-id*,
+  - a *using-declarator*,
+  - a *typename-specifier*,
+  - a *qualified-namespace-specifier*, or
+  - a *nested-name-specifier*, *elaborated-type-specifier*, or
+    *class-or-decltype* that has a *nested-name-specifier*
+    [[expr.prim.id.qual]].
+The *lookup context* of a member-qualified name is the type of its
+associated object expression (considered dependent if the object
+expression is type-dependent). The lookup context of any other qualified
+name is the type, template, or namespace nominated by the preceding
+*nested-name-specifier*.
+[*Note 1*: When parsing a class member access, the name following the
+`->` or `.` is a qualified name even though it is not yet known of which
+kind. — *end note*]
 [*Example 2*:
+In
 ``` cpp
+  N::C::m.Base::f()
 ```
+`Base` is a member-qualified name; the other qualified names are `C`,
+`m`, and `f`.
 — *end example*]
+*Qualified name lookup* in a class, namespace, or enumeration performs a
+search of the scope associated with it [[class.member.lookup]] except as
+specified below. Unless otherwise specified, a qualified name undergoes
+qualified name lookup in its lookup context from the point where it
+appears unless the lookup context either is dependent and is not the
+current instantiation [[temp.dep.type]] or is not a class or class
+template. If nothing is found by qualified lookup for a member-qualified
+name that is the terminal name [[expr.prim.id.unqual]] of a
+*nested-name-specifier* and is not dependent, it undergoes unqualified
+lookup.
+[*Note 2*: During lookup for a template specialization, no names are
+dependent. — *end note*]
 [*Example 3*:
+``` cpp
+int f();
+struct A {
+  int B, C;
+  template<int> using D = void;
+  using T = void;
+  void f();
+};
+using B = A;
+template<int> using C = A;
+template<int> using D = A;
+template<int> using X = A;
+template<class T>
+void g(T *p) {                  // as instantiated for g<A>:
+  p->X<0>::f();                 // error: A::X not found in ((p->X) < 0) > ::f()
+  p->template X<0>::f();        // OK, ::X found in definition context
+  p->B::f();                    // OK, non-type A::B ignored
+  p->template C<0>::f();        // error: A::C is not a template
+  p->template D<0>::f();        // error: A::D<0> is not a class type
+  p->T::f();                    // error: A::T is not a class type
+}
+template void g(A*);
+```
+— *end example*]
+If a qualified name Q follows a `~`:
+- If Q is a member-qualified name, it undergoes unqualified lookup as
+  well as qualified lookup.
+- Otherwise, its *nested-name-specifier* N shall nominate a type. If N
+  has another *nested-name-specifier* S, Q is looked up as if its lookup
+  context were that nominated by S.
+- Otherwise, if the terminal name of N is a member-qualified name M, Q
+  is looked up as if `\~`Q appeared in place of M (as above).
+- Otherwise, Q undergoes unqualified lookup.
+- Each lookup for Q considers only types (if Q is not followed by a `<`)
+  and templates whose specializations are types. If it finds nothing or
+  is ambiguous, it is discarded.
+- The *type-name* that is or contains Q shall refer to its (original)
+  lookup context (ignoring cv-qualification) under the interpretation
+  established by at least one (successful) lookup performed.
+[*Example 4*:
 ``` cpp
 struct C {
   typedef int I;
 };
 typedef int I1, I2;
 extern int* p;
 extern int* q;
+void f() {
   p->C::I::~I();        // I is looked up in the scope of C
+ q->I1::~I2(); // I2 is found by unqualified lookup
+}
 struct A {
   ~A();
 };
 typedef A AB;
 int main() {
 }
 ```
 — *end example*]
 #### Class members <a id="class.qual">[[class.qual]]</a>
+In a lookup for a qualified name N whose lookup context is a class C in
+which function names are not ignored,[^4]
+- if the search finds the injected-class-name of `C` [[class.pre]], or
+- if N is dependent and is the terminal name of a *using-declarator*
+  [[namespace.udecl]] that names a constructor,
+N is instead considered to name the constructor of class `C`. Such a
+constructor name shall be used only in the *declarator-id* of a (friend)
+declaration of a constructor or in a *using-declaration*.
 [*Example 1*:
 ``` cpp
 struct A { A(); };
 struct A::A a2;     // object of type A
 ```
 — *end example*]
 #### Namespace members <a id="namespace.qual">[[namespace.qual]]</a>
+Qualified name lookup in a namespace N additionally searches every
+element of the inline namespace set of N [[namespace.def]]. If nothing
+is found, the results of the lookup are the results of qualified name
+lookup in each namespace nominated by a *using-directive* that precedes
+the point of the lookup and inhabits N or an element of N’s inline
+namespace set.
+[*Note 1*: If a *using-directive* refers to a namespace that has
+already been considered, it does not affect the result. — *end note*]
 [*Example 1*:
 ``` cpp
 int x;
 }
 ```
 — *end example*]
+[*Note 2*:
 The same declaration found more than once is not an ambiguity (because
 it is still a unique declaration).
 [*Example 2*:
   using namespace C;
 }
 void f()
 {
+  BC::a++;          // OK, S is { `A::a`, `A::a` }
 }
 namespace D {
   using A::a;
 }
   using namespace D;
 }
 void g()
 {
+  BD::a++;          // OK, S is { `A::a`, `A::a` }
 }
 ```
 — *end example*]
   using namespace A;
 }
 void f()
 {
+  A::a++;           // OK, a declared directly in A, S is { `A::a` }
+  B::a++;           // OK, both A and B searched (once), S is { `A::a` }
+  A::b++;           // OK, both A and B searched (once), S is { `B::b` }
+  B::b++;           // OK, b declared directly in B, S is { `B::b` }
 }
 ```
 — *end example*]
+[*Note 3*: Class and enumeration declarations are not discarded because
+of other declarations found in other searches. — *end note*]
 [*Example 4*:
 ``` cpp
 namespace A {
 }
 ```
 — *end example*]
 ### Elaborated type specifiers <a id="basic.lookup.elab">[[basic.lookup.elab]]</a>
+If the *class-key* or `enum` keyword in an *elaborated-type-specifier*
+is followed by an *identifier* that is not followed by `::`, lookup for
+the *identifier* is type-only [[basic.lookup.general]].
+[*Note 1*: In general, the recognition of an
+*elaborated-type-specifier* depends on the following tokens. If the
+*identifier* is followed by `::`, see
+[[basic.lookup.qual]]. — *end note*]
+If the terminal name of the *elaborated-type-specifier* is a qualified
+name, lookup for it is type-only. If the name lookup does not find a
+previously declared *type-name*, the *elaborated-type-specifier* is
+ill-formed.
 [*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 {
+  struct Data;                  // OK, declares nested Data
+  struct ::Data*     thatData;  // OK, refers to ::Data
+  struct Base::Data* thisData;  // OK, refers to nested Data
+  friend class ::Data;          // OK, global Data is a friend
+  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*]
 ### Using-directives and namespace aliases <a id="basic.lookup.udir">[[basic.lookup.udir]]</a>

Diff to HTML by rtfpessoa