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

Files changed (1) hide show

tmp/tmp6n6_5ebr/{from.md → to.md} +103 -62

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

@@ -8,10 +8,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;
 };
@@ -20,31 +22,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
@@ -63,20 +71,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;
@@ -84,25 +93,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.
@@ -113,22 +127,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(); };
@@ -138,39 +156,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);
@@ -199,38 +220,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;
 }
@@ -248,11 +269,11 @@ namespace BC {
   using namespace C;
 }
 void f()
 {
-  BC::a++;          // OK: S is { A::a, A::a }
 }
 namespace D {
   using A::a;
 }
@@ -262,14 +283,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 {
@@ -285,25 +312,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;
@@ -319,10 +350,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
@@ -331,24 +364,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);
   }
@@ -363,5 +402,7 @@ namespace C {
 using namespace A;
 using namespace C::D;
 void B::f1(int){ }  // OK, defines A::B::f1(int)
 ```

 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*]

Diff to HTML by rtfpessoa