[namespace.qual] - C++20 → C++23

Files changed (1) hide show

tmp/tmpd05mp5d9/{from.md → to.md} +17 -88

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

@@ -1,30 +1,16 @@
 #### 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;
@@ -78,11 +64,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*:
@@ -105,11 +91,11 @@ namespace BC {
   using namespace C;
 }
 void f()
 {
-  BC::a++;          // OK: S is { `A::a`, `A::a` }
 }
 namespace D {
   using A::a;
 }
@@ -119,11 +105,11 @@ namespace BD {
   using namespace D;
 }
 void g()
 {
-  BD::a++;          // OK: S is { `A::a`, `A::a` }
 }
 ```
 — *end example*]
@@ -148,26 +134,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 {
@@ -188,57 +169,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*]

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