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

Files changed (1) hide show

tmp/tmpzzbx9avf/{from.md → to.md} +233 -133

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

@@ -1,34 +1,33 @@
 ## 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 declaration (
-[[basic.def]]) of that name. Name lookup shall find an unambiguous
-declaration for the name (see  [[class.member.lookup]]). Name lookup may
-associate more than one declaration with a name if it finds the name to
-be a function name; 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.
-[[basic.link]] discusses linkage issues. The notions of scope, point of
-declaration and name hiding are discussed in  [[basic.scope]].
 ### 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
@@ -41,12 +40,15 @@ become visible in a namespace enclosing the *using-directive*; see
 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]]. 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
@@ -54,37 +56,39 @@ typedef int f;
 namespace N {
   struct A {
     friend void f(A &);
     operator int();
     void g(A a) {
-      int i = f(a); // f is the typedef, not the friend
-                            // function: equivalent to int(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.
 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.
-A name used in the definition of a function following the function’s
-*declarator-id*[^4] that is a member of namespace `N` (where, only for
-the purpose of exposition, `N` could represent the global scope) 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.
 ``` cpp
 namespace A {
   namespace N {
     void f();
   }
@@ -97,30 +101,34 @@ void A::N::f() {
   // 3) scope of namespace A
   // 4) global scope, before the definition of A::N::f
 }
 ```
 A name used in the definition of a class `X` outside of a member
-function body, default argument, *exception-specification*,
 *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
   definition of class `X` in namespace `N` or in one of `N`’s enclosing
   namespaces.
 ``` cpp
 namespace M {
   class B { };
 }
 ```
@@ -140,21 +148,25 @@ namespace N {
 // 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
 ```
-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]].
-[[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.
 For the members of a class `X`, a name used in a member function body,
-in a default argument, in an *exception-specification*, 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:
@@ -172,10 +184,12 @@ declared in one of the following ways:
 - 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.
 ``` cpp
 class B { };
 namespace M {
   namespace N {
     class X : public B {
@@ -194,15 +208,18 @@ void M::N::X::f() {
 // 4) scope of namespace M::N
 // 5) scope of namespace M
 // 6) global scope, before the definition of M::N::X::f
 ```
-[[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.
 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
@@ -215,10 +232,12 @@ function declarator and not part of a *template-argument* in the
 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.
 ``` cpp
 struct A {
   typedef int AT;
   void f1(AT);
   void f2(float);
@@ -231,36 +250,44 @@ struct B {
   friend void A::f2(BT);      // parameter type is B::BT
   friend void A::f3<AT>();    // template argument is B::AT
 };
 ```
 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. [[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*.
 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`.
-[[class.static.data]] further describes the restrictions on the use of
-names in the definition of a `static` data member.
 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.
 ``` cpp
 namespace N {
   int i = 4;
   extern int j;
 }
@@ -268,21 +295,24 @@ namespace N {
 int i = 2;
 int N::j = i;       // N::j == 4
 ```
 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*.
-But function parameter names are found.
-The rules for name lookup in template definitions are described in
-[[temp.res]].
 ### 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
@@ -291,27 +321,30 @@ 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).
 ``` 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
 }
 ```
 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 is
 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:
@@ -326,12 +359,12 @@ way:
   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. Non-type template arguments do not contribute to the set of
-  associated namespaces.
 - 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
@@ -364,18 +397,22 @@ Let *X* be the lookup set produced by unqualified lookup (
 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 or 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*. The namespaces and classes associated with the argument types
-can include namespaces and classes already considered by the ordinary
-unqualified lookup.
 ``` cpp
 namespace NS {
   class T { };
   void f(T);
@@ -388,10 +425,12 @@ int main() {
   extern void g(NS::T, float);
   g(parm, 1);                   // OK: calls g(NS::T, float)
 }
 ```
 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.
@@ -412,10 +451,12 @@ enumeration. If a `::` scope resolution operator in a
 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.
 ``` cpp
 class A {
 public:
   static int n;
 };
@@ -424,31 +465,37 @@ int main() {
   A::n = 42;        // OK
   A b;              // ill-formed: A does not name a type
 }
 ```
-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.
 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.
 ``` cpp
 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];
-                    // not to: C::X C::arr[C::number];
 ```
 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
@@ -467,20 +514,21 @@ scope designated by the *nested-name-specifier*. Similarly, in a
 nested-name-specifierₒₚₜ class-name '::' '~' class-name
 ```
 the second *class-name* is looked up in the same scope as the first.
 ``` 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;
@@ -488,25 +536,30 @@ int main() {
   AB* p;
   p->AB::~AB();     // explicitly calls the destructor for A
 }
 ```
-[[basic.lookup.classref]] describes how name lookup proceeds after the
-`.` and `->` operators.
 #### 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]]). A class
-member can be referred to using a *qualified-id* at any point in its
-potential scope ([[basic.scope.class]]). The exceptions to the name
-lookup rule above are the following:
-- a destructor name is looked up 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.
@@ -517,22 +570,26 @@ lookup rule above are the following:
 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-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`. 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. Such a constructor name shall be used
-only in the *declarator-id* of a declaration that names a constructor or
-in a *using-declaration*.
 ``` cpp
 struct A { A(); };
 struct B: public A { B(); };
@@ -542,39 +599,42 @@ 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
 ```
 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, the name specified after the *nested-name-specifier* is
-looked up in the scope of the namespace. If a *qualified-id* starts with
-`::`, the name after the `::` is looked up in the global namespace. In
-either case, 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-directives* 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.
 ``` cpp
 int x;
 namespace Y {
   void f(float);
   void h(int);
@@ -603,38 +663,38 @@ namespace AB {
   void g();
 }
 void h()
 {
-  AB::g();          // g is declared directly in AB,
-                    // therefore S is { AB::g() } and AB::g() is chosen
-  AB::f(1);         // f is not declared directly in AB so the rules are
-                    // applied recursively to A and B;
-                    // namespace Y is not searched and Y::f(float)
-                    // is not considered;
-                    // S is { A::f(int), B::f(char) } and overload
-                    // resolution chooses A::f(int)
   AB::f('c');       // as above but resolution chooses B::f(char)
-  AB::x++;          // x is not declared directly in AB, and
-                    // is not declared in A or B , so the rules are
-                    // applied recursively to Y and Z,
- // S is { } so the program is ill-formed
-  AB::i++;          // i is not declared directly in AB so the rules are
-                    // applied recursively to A and B,
- // S is { A::i , B::i } so the use is ambiguous
-                    // and the program is ill-formed
-  AB::h(16.8);      // h is not declared directly in AB and
-                    // not declared directly in A or B so the rules are
-                    // applied recursively to Y and Z,
-                    // S is { Y::h(int), Z::h(double) } and overload
-                    // resolution chooses Z::h(double)
 }
 ```
 The same declaration found more than once is not an ambiguity (because
-it is still a unique declaration). For example:
 ``` cpp
 namespace A {
   int a;
 }
@@ -652,11 +712,11 @@ namespace BC {
   using namespace C;
 }
 void f()
 {
-  BC::a++;          // OK: S is { A::a, A::a }
 }
 namespace D {
   using A::a;
 }
@@ -666,14 +726,20 @@ namespace BD {
   using namespace D;
 }
 void g()
 {
-  BD::a++;          // OK: S is { A::a, A::a }
 }
 ```
 Because each referenced namespace is searched at most once, the
 following is well-defined:
 ``` cpp
 namespace B {
@@ -689,25 +755,29 @@ 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}
 }
 ```
 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.
 ``` cpp
 namespace A {
   struct x { };
   int x;
   int y;
@@ -723,10 +793,12 @@ namespace C {
   int i = C::x;     // OK, A::x (of type int)
   int j = C::y;     // ambiguous, A::y or B::y
 }
 ```
 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
@@ -735,24 +807,30 @@ 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.
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
   using namespace B;
 }
 void A::f1(int){ }  // ill-formed, f1 is not a member of A
 ```
 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*.
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
@@ -767,10 +845,12 @@ namespace C {
 using namespace A;
 using namespace C::D;
 void B::f1(int){ }  // OK, defines A::B::f1(int)
 ```
 ### 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 (
@@ -804,42 +884,44 @@ 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.
 ``` 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 {
   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
 ```
 ### 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
@@ -857,11 +939,13 @@ 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
-find a name that refers to (possibly cv-qualified) `T`.
 ``` cpp
 struct A { };
 struct B {
@@ -872,22 +956,34 @@ struct B {
 void B::f(::A* a) {
   a->~A();                      // OK: lookup in *a finds the injected-class-name
 }
 ```
 If the *id-expression* in a class member access is a *qualified-id* of
 the form
 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*. See  [[basic.lookup.qual]], which describes the
-lookup of a name before `::`, which will only find a type or namespace
-name.
 If the *qualified-id* has the form
 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
@@ -898,10 +994,12 @@ If the *id-expression* is a *conversion-function-id*, its
 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.
 ``` cpp
 struct A { };
 namespace N {
   struct A {
     void g() { }
@@ -913,10 +1011,12 @@ int main() {
   N::A a;
   a.operator A();               // calls N::A::operator N::A
 }
 ```
 ### Using-directives and namespace aliases <a id="basic.lookup.udir">[[basic.lookup.udir]]</a>
 In a *using-directive* or *namespace-alias-definition*, during the
 lookup for a *namespace-name* or for a name in a *nested-name-specifier*
 only namespace names are considered.

 ## 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*]
 ### 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
 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
 apply. The rules in  [[basic.lookup.argdep]] have no effect on the
 syntactic interpretation of an expression. For example,
 ``` cpp
 namespace N {
   struct A {
     friend void f(A &);
     operator int();
     void g(A a) {
+      int i = f(a); // f is the typedef, not the friend function: equivalent to int(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
 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*[^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 {
   namespace N {
     void f();
   }
   // 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` 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
   definition of class `X` in namespace `N` or in one of `N`’s enclosing
   namespaces.
+[*Example 2*:
 ``` cpp
 namespace M {
   class B { };
 }
 ```
 // 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 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:
 - 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 {
 // 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
 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);
   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* (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
 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
+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:
   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
 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 classes associated with the argument
+types can include namespaces and classes already considered by the
+ordinary unqualified lookup. — *end note*]
+[*Example 2*:
 ``` cpp
 namespace NS {
   class T { };
   void f(T);
   extern void g(NS::T, float);
   g(parm, 1);                   // OK: calls g(NS::T, float)
 }
 ```
+— *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.
 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 {
 public:
   static int n;
 };
   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.
+[*Example 2*:
 ``` cpp
 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
 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 {
   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;
   AB* p;
   p->AB::~AB();     // explicitly calls the destructor for A
 }
 ```
+— *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 (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.
 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
+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(); };
 struct B: public A { 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*]
 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]]). 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;
 namespace Y {
   void f(float);
   void h(int);
   void g();
 }
 void h()
 {
+  AB::g();          // g is declared directly in AB, therefore S is { `AB::g()` } and AB::g() is chosen
+  AB::f(1);         // f is not declared directly in AB so the rules are applied recursively to A and B;
+                    // namespace Y is not searched and Y::f(float) is not considered;
+                    // S is { `A::f(int)`, `B::f(char)` } and overload resolution chooses A::f(int)
   AB::f('c');       // as above but resolution chooses B::f(char)
+  AB::x++;          // x is not declared directly in AB, and is not declared in A or B, so the rules
+                    // are applied recursively to Y and Z, S is { } so the program is ill-formed
+  AB::i++;          // i is not declared directly in AB so the rules are applied recursively to A and B,
+                    // S is { `A::i`, `B::i` } so the use is ambiguous and the program is ill-formed
+  AB::h(16.8);      // h is not declared directly in AB and not declared directly in A or B so the rules
+                    // are applied recursively to Y and Z, S is { `Y::h(int)`, `Z::h(double)` } and
+ // overload resolution chooses Z::h(double)
 }
 ```
+— *end example*]
+[*Note 1*:
 The same declaration found more than once is not an ambiguity (because
+it is still a unique declaration).
+[*Example 2*:
 ``` cpp
 namespace A {
   int a;
 }
   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*]
+— *end note*]
+[*Example 3*:
 Because each referenced namespace is searched at most once, the
 following is well-defined:
 ``` cpp
 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
 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*:
 ``` cpp
 namespace A {
   struct x { };
   int x;
   int y;
   int i = C::x;     // OK, A::x (of type int)
   int j = C::y;     // ambiguous, A::y or B::y
 }
 ```
+— *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
 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
 *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);
   }
 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 (
 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 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 {
   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
 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 {
 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 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
 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 { };
 namespace N {
   struct A {
     void g() { }
   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>
 In a *using-directive* or *namespace-alias-definition*, during the
 lookup for a *namespace-name* or for a name in a *nested-name-specifier*
 only namespace names are considered.

Diff to HTML by rtfpessoa