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

Files changed (1) hide show

tmp/tmp17cl5uu_/{from.md → to.md} +29 -41

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

@@ -13,22 +13,19 @@ only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
 The optional *attribute-specifier-seq* appertains to the
 *using-directive*.
-A *using-directive* specifies that the names in the nominated namespace
-can be used in the scope in which the *using-directive* appears after
-the *using-directive*. During unqualified name lookup
-[[basic.lookup.unqual]], the names appear as if they were declared in
-the nearest enclosing namespace which contains both the
-*using-directive* and the nominated namespace.
-[*Note 2*: In this context, “contains” means “contains directly or
-indirectly”. — *end note*]
-A *using-directive* does not add any members to the declarative region
-in which it appears.
 [*Example 1*:
 ``` cpp
 namespace A {
@@ -58,18 +55,14 @@ void f4() {
 }
 ```
 — *end example*]
-For unqualified lookup [[basic.lookup.unqual]], the *using-directive* is
-transitive: if a scope contains a *using-directive* that nominates a
-second namespace that itself contains *using-directive*s, the effect is
-as if the *using-directive*s from the second namespace also appeared in
-the first.
-[*Note 3*: For qualified lookup, see
-[[namespace.qual]]. — *end note*]
 [*Example 2*:
 ``` cpp
 namespace M {
@@ -112,17 +105,15 @@ namespace B {
 }
 ```
 — *end example*]
-If a namespace is extended [[namespace.def]] after a *using-directive*
-for that namespace is given, the additional members of the extended
-namespace and the members of namespaces nominated by *using-directive*s
-in the extending *namespace-definition* can be used after the extending
-*namespace-definition*.
-[*Note 4*:
 If name lookup finds a declaration for a name in two different
 namespaces, and the declarations do not declare the same entity and do
 not declare functions or function templates, the use of the name is
 ill-formed [[basic.lookup]]. In particular, the name of a variable,
@@ -143,40 +134,37 @@ namespace B {
 using namespace A;
 using namespace B;
 void f() {
   X(1);             // error: name X found in two namespaces
-  g();              // OK: name g refers to the same entity
-  h();              // OK: overload resolution selects A::h
 }
 ```
 — *end note*]
-During overload resolution, all functions from the transitive search are
-considered for argument matching. The set of declarations found by the
-transitive search is unordered.
-[*Note 5*: In particular, the order in which namespaces were considered
-and the relationships among the namespaces implied by the
-*using-directive*s do not cause preference to be given to any of the
-declarations found by the search. — *end note*]
-An ambiguity exists if the best match finds two functions with the same
-signature, even if one is in a namespace reachable through
-*using-directive*s in the namespace of the other.[^11]
 [*Example 3*:
 ``` cpp
 namespace D {
   int d1;
   void f(char);
 }
 using namespace D;
-int d1;             // OK: no conflict with D::d1
 namespace E {
   int e;
   void f(int);
 }
@@ -189,14 +177,14 @@ namespace D {       // namespace extension
 void f() {
   d1++;             // error: ambiguous ::d1 or D::d1?
   ::d1++;           // OK
   D::d1++;          // OK
-  d2++;             // OK: D::d2
-  e++;              // OK: E::e
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
-  f('a');           // OK: D::f(char)
 }
 ```
 — *end example*]

 [[basic.lookup.udir]]. — *end note*]
 The optional *attribute-specifier-seq* appertains to the
 *using-directive*.
+[*Note 2*: A *using-directive* makes the names in the nominated
+namespace usable in the scope in which the *using-directive* appears
+after the *using-directive* [[basic.lookup.unqual]], [[namespace.qual]].
+During unqualified name lookup, the names appear as if they were
+declared in the nearest enclosing namespace which contains both the
+*using-directive* and the nominated namespace. — *end note*]
+[*Note 3*: A *using-directive* does not introduce any
+names. — *end note*]
 [*Example 1*:
 ``` cpp
 namespace A {
 }
 ```
 — *end example*]
+[*Note 4*: A *using-directive* is transitive: if a scope contains a
+*using-directive* that nominates a namespace that itself contains
+*using-directive*s, the namespaces nominated by those *using-directive*s
+are also eligible to be considered. — *end note*]
 [*Example 2*:
 ``` cpp
 namespace M {
 }
 ```
 — *end example*]
+[*Note 5*: Declarations in a namespace that appear after a
+*using-directive* for that namespace can be found through that
+*using-directive* after they appear. — *end note*]
+[*Note 6*:
 If name lookup finds a declaration for a name in two different
 namespaces, and the declarations do not declare the same entity and do
 not declare functions or function templates, the use of the name is
 ill-formed [[basic.lookup]]. In particular, the name of a variable,
 using namespace A;
 using namespace B;
 void f() {
   X(1);             // error: name X found in two namespaces
+  g();              // OK, name g refers to the same entity
+  h();              // OK, overload resolution selects A::h
 }
 ```
 — *end note*]
+[*Note 7*:
+The order in which namespaces are considered and the relationships among
+the namespaces implied by the *using-directive*s do not affect overload
+resolution. Neither is any function excluded because another has the
+same signature, even if one is in a namespace reachable through
+*using-directive*s in the namespace of the other.[^10]
+— *end note*]
 [*Example 3*:
 ``` cpp
 namespace D {
   int d1;
   void f(char);
 }
 using namespace D;
+int d1;             // OK, no conflict with D::d1
 namespace E {
   int e;
   void f(int);
 }
 void f() {
   d1++;             // error: ambiguous ::d1 or D::d1?
   ::d1++;           // OK
   D::d1++;          // OK
+  d2++;             // OK, D::d2
+  e++;              // OK, E::e
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
+  f('a');           // OK, D::f(char)
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa