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

Files changed (1) hide show

tmp/tmpocjgw56q/{from.md → to.md} +137 -179

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

@@ -1,16 +1,15 @@
 ### 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 {
@@ -20,70 +19,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() {
@@ -92,55 +158,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(); };
@@ -154,39 +187,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;
@@ -240,11 +255,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*:
@@ -267,11 +282,11 @@ namespace BC {
   using namespace C;
 }
 void f()
 {
-  BC::a++;          // OK: S is { `A::a`, `A::a` }
 }
 namespace D {
   using A::a;
 }
@@ -281,11 +296,11 @@ namespace BD {
   using namespace D;
 }
 void g()
 {
-  BD::a++;          // OK: S is { `A::a`, `A::a` }
 }
 ```
 — *end example*]
@@ -310,26 +325,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 {
@@ -350,57 +360,5 @@ 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*]

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

Diff to HTML by rtfpessoa