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

Files changed (1) hide show

tmp/tmp_tsy78t9/{from.md → to.md} +43 -45

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

@@ -1,10 +1,10 @@
 ### Qualified name lookup <a id="basic.lookup.qual">[[basic.lookup.qual]]</a>
 The name of a class or namespace member or enumerator can be referred to
-after the `::` scope resolution operator ([[expr.prim]]) applied to a
-*nested-name-specifier* that denotes its class, namespace, or
 enumeration. If a `::` scope resolution operator in a
 *nested-name-specifier* is not preceded by a *decltype-specifier*,
 lookup of the name preceding that `::` considers only namespaces, types,
 and templates whose specializations are types. If the name found does
 not designate a namespace or a class, enumeration, or dependent type,
@@ -18,19 +18,19 @@ public:
   static int n;
 };
 int main() {
   int A;
   A::n = 42;        // OK
-  A b;              // ill-formed: A does not name a type
 }
 ```
 — *end example*]
 [*Note 1*: Multiply qualified names, such as `N1::N2::N3::n`, can be
-used to refer to members of nested classes ([[class.nest]]) or members
-of nested namespaces. — *end note*]
 In a declaration in which the *declarator-id* is a *qualified-id*, names
 used before the *qualified-id* being declared are looked up in the
 defining namespace scope; names following the *qualified-id* are looked
 up in the scope of the member’s class or namespace.
@@ -42,38 +42,35 @@ class X { };
 class C {
   class X { };
   static const int number = 50;
   static X arr[number];
 };
-X C::arr[number];   // ill-formed:
                     // equivalent to ::X C::arr[C::number];
                     // and not to C::X C::arr[C::number];
 ```
 — *end example*]
-A name prefixed by the unary scope operator `::` ([[expr.prim]]) is
-looked up in global scope, in the translation unit where it is used. The
-name shall be declared in global namespace scope or shall be a name
 whose declaration is visible in global scope because of a
-*using-directive* ([[namespace.qual]]). The use of `::` allows a global
-name to be referred to even if its identifier has been hidden (
-[[basic.scope.hiding]]).
 A name prefixed by a *nested-name-specifier* that nominates an
 enumeration type shall represent an *enumerator* of that enumeration.
-If a *pseudo-destructor-name* ([[expr.pseudo]]) contains a
-*nested-name-specifier*, the *type-name*s are looked up as types in the
-scope designated by the *nested-name-specifier*. Similarly, in a
-*qualified-id* of the form:
 ``` bnf
-nested-name-specifierₒₚₜ class-name '::' '~' class-name
 ```
-the second *class-name* is looked up in the same scope as the first.
 [*Example 3*:
 ``` cpp
 struct C {
@@ -102,40 +99,39 @@ proceeds after the `.` and `->` operators. — *end note*]
 #### Class members <a id="class.qual">[[class.qual]]</a>
 If the *nested-name-specifier* of a *qualified-id* nominates a class,
 the name specified after the *nested-name-specifier* is looked up in the
-scope of the class ([[class.member.lookup]]), except for the cases
-listed below. The name shall represent one or more members of that class
-or of one of its base classes (Clause  [[class.derived]]).
 [*Note 1*: A class member can be referred to using a *qualified-id* at
-any point in its potential scope (
-[[basic.scope.class]]). — *end note*]
 The exceptions to the name lookup rule above are the following:
 - the lookup for a destructor is as specified in  [[basic.lookup.qual]];
 - a *conversion-type-id* of a *conversion-function-id* is looked up in
   the same manner as a *conversion-type-id* in a class member access
   (see  [[basic.lookup.classref]]);
 - the names in a *template-argument* of a *template-id* are looked up in
-  the context in which the entire *postfix-expression* occurs.
-- the lookup for a name specified in a *using-declaration* (
-  [[namespace.udecl]]) also finds class or enumeration names hidden
-  within the same scope ([[basic.scope.hiding]]).
-In a lookup in which function names are not ignored[^9] and the
 *nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
-  up in `C`, is the injected-class-name of `C` (Clause  [[class]]), or
-- in a *using-declarator* of a *using-declaration* (
- [[namespace.udecl]]) that is a *member-declaration*, if the name
- specified after the *nested-name-specifier* is the same as the
-  *identifier* or the *simple-template-id*’s *template-name* in the last
- component of the *nested-name-specifier*,
 the name is instead considered to name the constructor of class `C`.
 [*Note 2*: For example, the constructor is not an acceptable lookup
 result in an *elaborated-type-specifier* so the constructor would not be
@@ -152,11 +148,11 @@ struct B: public A { B(); };
 A::A() { }
 B::B() { }
 B::A ba;            // object of type A
-A::A a;             // error, A::A is not a type name
 struct A::A a2;     // object of type A
 ```
 — *end example*]
@@ -173,22 +169,24 @@ nominating the global namespace), the name specified after the
 names in a *template-argument* of a *template-id* are looked up in the
 context in which the entire *postfix-expression* occurs.
 For a namespace `X` and name `m`, the namespace-qualified lookup set
 S(X, m) is defined as follows: Let S'(X, m) be the set of all
-declarations of `m` in `X` and the inline namespace set of `X` (
-[[namespace.def]]). If S'(X, m) is not empty, S(X, m) is S'(X, m);
 otherwise, S(X, m) is the union of S(Nᵢ, m) for all namespaces Nᵢ
 nominated by *using-directive*s in `X` and its inline namespace set.
 Given `X::m` (where `X` is a user-declared namespace), or given `::m`
 (where X is the global namespace), if S(X, m) is the empty set, the
 program is ill-formed. Otherwise, if S(X, m) has exactly one member, or
-if the context of the reference is a *using-declaration* (
-[[namespace.udecl]]), S(X, m) is the required set of declarations of
-`m`. Otherwise if the use of `m` is not one that allows a unique
-declaration to be chosen from S(X, m), the program is ill-formed.
 [*Example 1*:
 ``` cpp
 int x;
@@ -324,11 +322,11 @@ void f()
 — *end example*]
 During the lookup of a qualified namespace member name, if the lookup
 finds more than one declaration of the member, and if one declaration
 introduces a class name or enumeration name and the other declarations
-either introduce the same variable, the same enumerator or a set of
 functions, the non-type name hides the class or enumeration name if and
 only if the declarations are from the same namespace; otherwise (the
 declarations are from different namespaces), the program is ill-formed.
 [*Example 4*:
@@ -361,23 +359,23 @@ has the form
 ``` bnf
 nested-name-specifier unqualified-id
 ```
 the *unqualified-id* shall name a member of the namespace designated by
-the *nested-name-specifier* or of an element of the inline namespace
-set ([[namespace.def]]) of that namespace.
 [*Example 5*:
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
   using namespace B;
 }
-void A::f1(int){ }  // ill-formed, f1 is not a member of A
 ```
 — *end example*]
 However, in such namespace member declarations, the

 ### Qualified name lookup <a id="basic.lookup.qual">[[basic.lookup.qual]]</a>
 The name of a class or namespace member or enumerator can be referred to
+after the `::` scope resolution operator [[expr.prim.id.qual]] applied
+to a *nested-name-specifier* that denotes its class, namespace, or
 enumeration. If a `::` scope resolution operator in a
 *nested-name-specifier* is not preceded by a *decltype-specifier*,
 lookup of the name preceding that `::` considers only namespaces, types,
 and templates whose specializations are types. If the name found does
 not designate a namespace or a class, enumeration, or dependent type,
   static int n;
 };
 int main() {
   int A;
   A::n = 42;        // OK
+  A b;              // error: A does not name a type
 }
 ```
 — *end example*]
 [*Note 1*: Multiply qualified names, such as `N1::N2::N3::n`, can be
+used to refer to members of nested classes [[class.nest]] or members of
+nested namespaces. — *end note*]
 In a declaration in which the *declarator-id* is a *qualified-id*, names
 used before the *qualified-id* being declared are looked up in the
 defining namespace scope; names following the *qualified-id* are looked
 up in the scope of the member’s class or namespace.
 class C {
   class X { };
   static const int number = 50;
   static X arr[number];
 };
+X C::arr[number];   // error:
                     // equivalent to ::X C::arr[C::number];
                     // and not to C::X C::arr[C::number];
 ```
 — *end example*]
+A name prefixed by the unary scope operator `::` [[expr.prim.id.qual]]
+is looked up in global scope, in the translation unit where it is used.
+The name shall be declared in global namespace scope or shall be a name
 whose declaration is visible in global scope because of a
+*using-directive* [[namespace.qual]]. The use of `::` allows a global
+name to be referred to even if its identifier has been hidden
+[[basic.scope.hiding]].
 A name prefixed by a *nested-name-specifier* that nominates an
 enumeration type shall represent an *enumerator* of that enumeration.
+In a *qualified-id* of the form:
 ``` bnf
+nested-name-specifierₒₚₜ type-name '::' '~' type-name
 ```
+the second *type-name* is looked up in the same scope as the first.
 [*Example 3*:
 ``` cpp
 struct C {
 #### Class members <a id="class.qual">[[class.qual]]</a>
 If the *nested-name-specifier* of a *qualified-id* nominates a class,
 the name specified after the *nested-name-specifier* is looked up in the
+scope of the class [[class.member.lookup]], except for the cases listed
+below. The name shall represent one or more members of that class or of
+one of its base classes [[class.derived]].
 [*Note 1*: A class member can be referred to using a *qualified-id* at
+any point in its potential scope [[basic.scope.class]]. — *end note*]
 The exceptions to the name lookup rule above are the following:
 - the lookup for a destructor is as specified in  [[basic.lookup.qual]];
 - a *conversion-type-id* of a *conversion-function-id* is looked up in
   the same manner as a *conversion-type-id* in a class member access
   (see  [[basic.lookup.classref]]);
 - the names in a *template-argument* of a *template-id* are looked up in
+  the context in which the entire *postfix-expression* occurs;
+- the lookup for a name specified in a *using-declaration*
+  [[namespace.udecl]] also finds class or enumeration names hidden
+  within the same scope [[basic.scope.hiding]].
+In a lookup in which function names are not ignored[^8] and the
 *nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
+  up in `C`, is the injected-class-name of `C` [[class.pre]], or
+- in a *using-declarator* of a *using-declaration* [[namespace.udecl]]
+  that is a *member-declaration*, if the name specified after the
+  *nested-name-specifier* is the same as the *identifier* or the
+  *simple-template-id*’s *template-name* in the last component of the
+  *nested-name-specifier*,
 the name is instead considered to name the constructor of class `C`.
 [*Note 2*: For example, the constructor is not an acceptable lookup
 result in an *elaborated-type-specifier* so the constructor would not be
 A::A() { }
 B::B() { }
 B::A ba;            // object of type A
+A::A a;             // error: A::A is not a type name
 struct A::A a2;     // object of type A
 ```
 — *end example*]
 names in a *template-argument* of a *template-id* are looked up in the
 context in which the entire *postfix-expression* occurs.
 For a namespace `X` and name `m`, the namespace-qualified lookup set
 S(X, m) is defined as follows: Let S'(X, m) be the set of all
+declarations of `m` in `X` and the inline namespace set of `X`
+[[namespace.def]] whose potential scope [[basic.scope.namespace]] would
+include the namespace in which `m` is declared at the location of the
+*nested-name-specifier*. If S'(X, m) is not empty, S(X, m) is S'(X, m);
 otherwise, S(X, m) is the union of S(Nᵢ, m) for all namespaces Nᵢ
 nominated by *using-directive*s in `X` and its inline namespace set.
 Given `X::m` (where `X` is a user-declared namespace), or given `::m`
 (where X is the global namespace), if S(X, m) is the empty set, the
 program is ill-formed. Otherwise, if S(X, m) has exactly one member, or
+if the context of the reference is a *using-declaration*
+[[namespace.udecl]], S(X, m) is the required set of declarations of `m`.
+Otherwise if the use of `m` is not one that allows a unique declaration
+to be chosen from S(X, m), the program is ill-formed.
 [*Example 1*:
 ``` cpp
 int x;
 — *end example*]
 During the lookup of a qualified namespace member name, if the lookup
 finds more than one declaration of the member, and if one declaration
 introduces a class name or enumeration name and the other declarations
+introduce either the same variable, the same enumerator, or a set of
 functions, the non-type name hides the class or enumeration name if and
 only if the declarations are from the same namespace; otherwise (the
 declarations are from different namespaces), the program is ill-formed.
 [*Example 4*:
 ``` bnf
 nested-name-specifier unqualified-id
 ```
 the *unqualified-id* shall name a member of the namespace designated by
+the *nested-name-specifier* or of an element of the inline namespace set
+[[namespace.def]] of that namespace.
 [*Example 5*:
 ``` cpp
 namespace A {
   namespace B {
     void f1(int);
   }
   using namespace B;
 }
+void A::f1(int){ }  // error: f1 is not a member of A
 ```
 — *end example*]
 However, in such namespace member declarations, the

Diff to HTML by rtfpessoa