[namespace.udecl] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpj9v8da2b/{from.md → to.md} +46 -10

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

@@ -146,18 +146,37 @@ void f() {
 — *end example*]
 If a declaration is named by two *using-declarator*s that inhabit the
 same class scope, the program is ill-formed.
 [*Note 3*: A *using-declarator* whose *nested-name-specifier* names a
 namespace does not name declarations added to the namespace after it.
 Thus, additional overloads added after the *using-declaration* are
 ignored, but default function arguments [[dcl.fct.default]], default
 template arguments [[temp.param]], and template specializations
 [[temp.spec.partial]], [[temp.expl.spec]] are considered. — *end note*]
-[*Example 5*:
 ``` cpp
 namespace A {
   void f(int);
 }
@@ -178,21 +197,37 @@ void bar() {
 ```
 — *end example*]
 If a declaration named by a *using-declaration* that inhabits the target
-scope of another declaration potentially conflicts with it
 [[basic.scope.scope]], and either is reachable from the other, the
-program is ill-formed. If two declarations named by *using-declaration*s
-that inhabit the same scope potentially conflict, either is reachable
-from the other, and they do not both declare functions or function
-templates, the program is ill-formed.
 [*Note 4*: Overload resolution possibly cannot distinguish between
 conflicting function declarations. — *end note*]
-[*Example 6*:
 ``` cpp
 namespace A {
   int x;
   int f(int);
@@ -224,10 +259,11 @@ void func() {
   using A::g;                           // error: conflicts with B::g
   void h();
   using A::h;                           // error: conflicts
   using B::x;
   using A::x;                           // OK, hides struct B::x
   x = 99;                               // assigns to A::x
   struct x x1;                          // x1 has class type B::x
 }
 ```
@@ -236,11 +272,11 @@ void func() {
 The set of declarations named by a *using-declarator* that inhabits a
 class `C` does not include member functions and member function
 templates of a base class that correspond to (and thus would conflict
 with) a declaration of a function or function template in `C`.
-[*Example 7*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
@@ -322,11 +358,11 @@ names a constructor, no access check is performed.
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
-[*Example 8*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
@@ -351,11 +387,11 @@ A *using-declaration* has the usual accessibility for a
 *member-declaration*. Base-class constructors considered because of a
 *using-declarator* are accessible if they would be accessible when used
 to construct an object of the base class; the accessibility of the
 *using-declaration* is ignored.
-[*Example 9*:
 ``` cpp
 class A {
 private:
     void f(char);

 — *end example*]
 If a declaration is named by two *using-declarator*s that inhabit the
 same class scope, the program is ill-formed.
+[*Example 5*:
+``` cpp
+struct C {
+  int i;
+};
+struct D1 : C { };
+struct D2 : C { };
+struct D3 : D1, D2 {
+  using D1::i;                  // OK, equivalent to using C::i
+  using D1::i;                  // error: duplicate
+  using D2::i;                  // error: duplicate, also names C::i
+};
+```
+— *end example*]
 [*Note 3*: A *using-declarator* whose *nested-name-specifier* names a
 namespace does not name declarations added to the namespace after it.
 Thus, additional overloads added after the *using-declaration* are
 ignored, but default function arguments [[dcl.fct.default]], default
 template arguments [[temp.param]], and template specializations
 [[temp.spec.partial]], [[temp.expl.spec]] are considered. — *end note*]
+[*Example 6*:
 ``` cpp
 namespace A {
   void f(int);
 }
 ```
 — *end example*]
 If a declaration named by a *using-declaration* that inhabits the target
+scope of another declaration B potentially conflicts with it
 [[basic.scope.scope]], and either is reachable from the other, the
+program is ill-formed unless B is name-independent and the
+*using-declaration* precedes B.
+[*Example 7*:
+``` cpp
+int _;
+void f() {
+  int _;                // B
+  _ = 0;
+  using ::_;            // error: using-declaration does not precede B
+}
+```
+— *end example*]
+If two declarations named by *using-declaration*s that inhabit the same
+scope potentially conflict, either is reachable from the other, and they
+do not both declare functions or function templates, the program is
+ill-formed.
 [*Note 4*: Overload resolution possibly cannot distinguish between
 conflicting function declarations. — *end note*]
+[*Example 8*:
 ``` cpp
 namespace A {
   int x;
   int f(int);
   using A::g;                           // error: conflicts with B::g
   void h();
   using A::h;                           // error: conflicts
   using B::x;
   using A::x;                           // OK, hides struct B::x
+  using A::x;                           // OK, does not conflict with previous using A::x
   x = 99;                               // assigns to A::x
   struct x x1;                          // x1 has class type B::x
 }
 ```
 The set of declarations named by a *using-declarator* that inhabits a
 class `C` does not include member functions and member function
 templates of a base class that correspond to (and thus would conflict
 with) a declaration of a function or function template in `C`.
+[*Example 9*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
+[*Example 10*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
 *member-declaration*. Base-class constructors considered because of a
 *using-declarator* are accessible if they would be accessible when used
 to construct an object of the base class; the accessibility of the
 *using-declaration* is ignored.
+[*Example 11*:
 ``` cpp
 class A {
 private:
     void f(char);

Diff to HTML by rtfpessoa