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

Files changed (1) hide show

tmp/tmp6ozy9p9n/{from.md → to.md} +67 -235

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

@@ -1,18 +1,20 @@
 ## Namespaces <a id="basic.namespace">[[basic.namespace]]</a>
-A namespace is an optionally-named declarative region. The name of a
-namespace can be used to access entities declared in that namespace;
-that is, the members of the namespace. Unlike other declarative regions,
-the definition of a namespace can be split over several parts of one or
-more translation units.
-[*Note 1*: A namespace name with external linkage is exported if any of
-its *namespace-definition*s is exported, or if it contains any
 *export-declaration*s [[module.interface]]. A namespace is never
-attached to a module, and never has module linkage even if it is not
-exported. — *end note*]
 [*Example 1*:
 ``` cpp
 export module M;
@@ -21,15 +23,21 @@ export namespace N2 {}          // N2 is exported
 namespace N3 { export int n; }  // N3 is exported
 ```
 — *end example*]
-The outermost declarative region of a translation unit is a namespace;
-see  [[basic.scope.namespace]].
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
 ``` bnf
 namespace-name:
         identifier
         namespace-alias
 ```
@@ -65,22 +73,20 @@ enclosing-namespace-specifier:
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
-Every *namespace-definition* shall appear at namespace scope
 [[basic.scope.namespace]].
-In a *named-namespace-definition*, the *identifier* is the name of the
-namespace. If the *identifier*, when looked up [[basic.lookup.unqual]],
-refers to a *namespace-name* (but not a *namespace-alias*) that was
-introduced in the namespace in which the *named-namespace-definition*
-appears or that was introduced in a member of the inline namespace set
-of that namespace, the *namespace-definition* *extends* the
-previously-declared namespace. Otherwise, the *identifier* is introduced
-as a *namespace-name* into the declarative region in which the
-*named-namespace-definition* appears.
 Because a *namespace-definition* contains *declaration*s in its
 *namespace-body* and a *namespace-definition* is itself a *declaration*,
 it follows that *namespace-definition*s can be nested.
@@ -97,34 +103,10 @@ namespace Outer {
 }
 ```
 — *end example*]
-The *enclosing namespaces* of a declaration are those namespaces in
-which the declaration lexically appears, except for a redeclaration of a
-namespace member outside its original namespace (e.g., a definition as
-specified in  [[namespace.memdef]]). Such a redeclaration has the same
-enclosing namespaces as the original declaration.
-[*Example 2*:
-``` cpp
-namespace Q {
-  namespace V {
-    void f();                   // enclosing namespaces are the global namespace, Q, and Q::V
-    class C { void m(); };
-  }
-  void V::f() {                 // enclosing namespaces are the global namespace, Q, and Q::V
-    extern void h();            // ... so this declares Q::V::h
-  }
-  void V::C::m() {              // enclosing namespaces are the global namespace, Q, and Q::V
-  }
-}
-```
-— *end example*]
 If the optional initial `inline` keyword appears in a
 *namespace-definition* for a particular namespace, that namespace is
 declared to be an *inline namespace*. The `inline` keyword may be used
 on a *namespace-definition* that extends a namespace only if it was
 previously used on the *namespace-definition* that initially declared
@@ -132,33 +114,30 @@ the *namespace-name* for that namespace.
 The optional *attribute-specifier-seq* in a *named-namespace-definition*
 appertains to the namespace being defined or extended.
 Members of an inline namespace can be used in most respects as though
-they were members of the enclosing namespace. Specifically, the inline
-namespace and its enclosing namespace are both added to the set of
-associated namespaces used in argument-dependent lookup
 [[basic.lookup.argdep]] whenever one of them is, and a *using-directive*
 [[namespace.udir]] that names the inline namespace is implicitly
 inserted into the enclosing namespace as for an unnamed namespace
 [[namespace.unnamed]]. Furthermore, each member of the inline namespace
-can subsequently be partially specialized [[temp.class.spec]],
 explicitly instantiated [[temp.explicit]], or explicitly specialized
 [[temp.expl.spec]] as though it were a member of the enclosing
 namespace. Finally, looking up a name in the enclosing namespace via
 explicit qualification [[namespace.qual]] will include members of the
-inline namespace brought in by the *using-directive* even if there are
-declarations of that name in the enclosing namespace.
 These properties are transitive: if a namespace `N` contains an inline
 namespace `M`, which in turn contains an inline namespace `O`, then the
 members of `O` can be used as though they were members of `M` or `N`.
 The *inline namespace set* of `N` is the transitive closure of all
-inline namespaces in `N`. The *enclosing namespace set* of `O` is the
-set of namespaces consisting of the innermost non-inline namespace
-enclosing an inline namespace `O`, together with any intervening inline
-namespaces.
 A *nested-namespace-definition* with an *enclosing-namespace-specifier*
 `E`, *identifier* `I` and *namespace-body* `B` is equivalent to
 ``` cpp
@@ -166,11 +145,11 @@ namespace E { \opt{inline} namespace I { B } }
 ```
 where the optional `inline` is present if and only if the *identifier*
 `I` is preceded by `inline`.
-[*Example 3*:
 ``` cpp
 namespace A::inline B::C {
   int i;
 }
@@ -229,128 +208,10 @@ void h() {
 }
 ```
 — *end example*]
-#### Namespace member definitions <a id="namespace.memdef">[[namespace.memdef]]</a>
-A declaration in a namespace `N` (excluding declarations in nested
-scopes) whose *declarator-id* is an *unqualified-id* [[dcl.meaning]],
-whose *class-head-name* [[class.pre]] or *enum-head-name* [[dcl.enum]]
-is an *identifier*, or whose *elaborated-type-specifier* is of the form
-*class-key* *attribute-specifier-seq*ₒₚₜ  *identifier*
-[[dcl.type.elab]], or that is an *opaque-enum-declaration*, declares (or
-redeclares) its *unqualified-id* or *identifier* as a member of `N`.
-[*Note 1*: An explicit instantiation [[temp.explicit]] or explicit
-specialization [[temp.expl.spec]] of a template does not introduce a
-name and thus may be declared using an *unqualified-id* in a member of
-the enclosing namespace set, if the primary template is declared in an
-inline namespace. — *end note*]
-[*Example 1*:
-``` cpp
-namespace X {
-  void f() { ... }        // OK: introduces X::f()
-  namespace M {
-    void g();                   // OK: introduces X::M::g()
-  }
-  using M::g;
-  void g();                     // error: conflicts with X::M::g()
-}
-```
-— *end example*]
-Members of a named namespace can also be defined outside that namespace
-by explicit qualification [[namespace.qual]] of the name being defined,
-provided that the entity being defined was already declared in the
-namespace and the definition appears after the point of declaration in a
-namespace that encloses the declaration’s namespace.
-[*Example 2*:
-``` cpp
-namespace Q {
-  namespace V {
-    void f();
-  }
-  void V::f() { ... }     // OK
-  void V::g() { ... }     // error: g() is not yet a member of V
-  namespace V {
-    void g();
-  }
-}
-namespace R {
-  void Q::V::g() { ... }  // error: R doesn't enclose Q
-}
-```
-— *end example*]
-If a friend declaration in a non-local class first declares a class,
-function, class template or function template[^10] the friend is a
-member of the innermost enclosing namespace. The friend declaration does
-not by itself make the name visible to unqualified lookup
-[[basic.lookup.unqual]] or qualified lookup [[basic.lookup.qual]].
-[*Note 2*: The name of the friend will be visible in its namespace if a
-matching declaration is provided at namespace scope (either before or
-after the class definition granting friendship). — *end note*]
-If a friend function or function template is called, its name may be
-found by the name lookup that considers functions from namespaces and
-classes associated with the types of the function arguments
-[[basic.lookup.argdep]]. If the name in a friend declaration is neither
-qualified nor a *template-id* and the declaration is a function or an
-*elaborated-type-specifier*, the lookup to determine whether the entity
-has been previously declared shall not consider any scopes outside the
-innermost enclosing namespace.
-[*Note 3*: The other forms of friend declarations cannot declare a new
-member of the innermost enclosing namespace and thus follow the usual
-lookup rules. — *end note*]
-[*Example 3*:
-``` cpp
-// Assume f and g have not yet been declared.
-void h(int);
-template <class T> void f2(T);
-namespace A {
-  class X {
-    friend void f(X);           // A::f(X) is a friend
-    class Y {
-      friend void g();          // A::g is a friend
-      friend void h(int);       // A::h is a friend
-                                // ::h not considered
-      friend void f2<>(int);    // ::f2<>(int) is a friend
-    };
-  };
-  // A::f, A::g and A::h are not visible here
-  X x;
-  void g() { f(x); }            // definition of A::g
-  void f(X) { ... }       // definition of A::f
-  void h(int) { ... }     // definition of A::h
-  // A::f, A::g and A::h are visible here and known to be friends
-}
-using A::x;
-void h() {
-  A::f(x);
-  A::X::f(x);                   // error: f is not a member of A::X
-  A::X::Y::g();                 // error: g is not a member of A::X::Y
-}
-```
-— *end example*]
 ### Namespace alias <a id="namespace.alias">[[namespace.alias]]</a>
 A *namespace-alias-definition* declares an alternate name for a
 namespace according to the following grammar:
@@ -367,35 +228,18 @@ namespace-alias-definition:
 ``` bnf
 qualified-namespace-specifier:
     nested-name-specifierₒₚₜ namespace-name
 ```
-The *identifier* in a *namespace-alias-definition* is a synonym for the
-name of the namespace denoted by the *qualified-namespace-specifier* and
-becomes a *namespace-alias*.
 [*Note 1*: When looking up a *namespace-name* in a
 *namespace-alias-definition*, only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
-In a declarative region, a *namespace-alias-definition* can be used to
-redefine a *namespace-alias* declared in that declarative region to
-refer only to the namespace to which it already refers.
-[*Example 1*:
-The following declarations are well-formed:
-``` cpp
-namespace Company_with_very_long_name { ... }
-namespace CWVLN = Company_with_very_long_name;
-namespace CWVLN = Company_with_very_long_name;  // OK: duplicate
-namespace CWVLN = CWVLN;
-```
-— *end example*]
 ### Using namespace directive <a id="namespace.udir">[[namespace.udir]]</a>
 ``` bnf
 using-directive:
     attribute-specifier-seqₒₚₜ using namespace nested-name-specifierₒₚₜ namespace-name ';'
@@ -409,22 +253,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 {
@@ -454,18 +295,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 {
@@ -508,17 +345,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,
@@ -539,40 +374,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);
 }
@@ -585,14 +417,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*]

 ## Namespaces <a id="basic.namespace">[[basic.namespace]]</a>
+### General <a id="basic.namespace.general">[[basic.namespace.general]]</a>
+A namespace is an optionally-named entity whose scope can contain
+declarations of any kind of entity. The name of a namespace can be used
+to access entities that belong to that namespace; that is, the *members*
+of the namespace. Unlike other entities, the definition of a namespace
+can be split over several parts of one or more translation units and
+modules.
+[*Note 1*: A *namespace-definition* is exported if it contains any
 *export-declaration*s [[module.interface]]. A namespace is never
+attached to a named module and never has a name with module
+linkage. — *end note*]
 [*Example 1*:
 ``` cpp
 export module M;
 namespace N3 { export int n; }  // N3 is exported
 ```
 — *end example*]
+There is a *global namespace* with no declaration; see
+[[basic.scope.namespace]]. The global namespace belongs to the global
+scope; it is not an unnamed namespace [[namespace.unnamed]].
+[*Note 2*: Lacking a declaration, it cannot be found by name
+lookup. — *end note*]
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
+#### General <a id="namespace.def.general">[[namespace.def.general]]</a>
 ``` bnf
 namespace-name:
         identifier
         namespace-alias
 ```
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
+Every *namespace-definition* shall inhabit a namespace scope
 [[basic.scope.namespace]].
+In a *named-namespace-definition* D, the *identifier* is the name of the
+namespace. The *identifier* is looked up by searching for it in the
+scopes of the namespace A in which D appears and of every element of the
+inline namespace set of A. If the lookup finds a *namespace-definition*
+for a namespace N, D *extends* N, and the target scope of D is the scope
+to which N belongs. If the lookup finds nothing, the *identifier* is
+introduced as a *namespace-name* into A.
 Because a *namespace-definition* contains *declaration*s in its
 *namespace-body* and a *namespace-definition* is itself a *declaration*,
 it follows that *namespace-definition*s can be nested.
 }
 ```
 — *end example*]
 If the optional initial `inline` keyword appears in a
 *namespace-definition* for a particular namespace, that namespace is
 declared to be an *inline namespace*. The `inline` keyword may be used
 on a *namespace-definition* that extends a namespace only if it was
 previously used on the *namespace-definition* that initially declared
 The optional *attribute-specifier-seq* in a *named-namespace-definition*
 appertains to the namespace being defined or extended.
 Members of an inline namespace can be used in most respects as though
+they were members of the innermost enclosing namespace. Specifically,
+the inline namespace and its enclosing namespace are both added to the
+set of associated namespaces used in argument-dependent lookup
 [[basic.lookup.argdep]] whenever one of them is, and a *using-directive*
 [[namespace.udir]] that names the inline namespace is implicitly
 inserted into the enclosing namespace as for an unnamed namespace
 [[namespace.unnamed]]. Furthermore, each member of the inline namespace
+can subsequently be partially specialized [[temp.spec.partial]],
 explicitly instantiated [[temp.explicit]], or explicitly specialized
 [[temp.expl.spec]] as though it were a member of the enclosing
 namespace. Finally, looking up a name in the enclosing namespace via
 explicit qualification [[namespace.qual]] will include members of the
+inline namespace even if there are declarations of that name in the
+enclosing namespace.
 These properties are transitive: if a namespace `N` contains an inline
 namespace `M`, which in turn contains an inline namespace `O`, then the
 members of `O` can be used as though they were members of `M` or `N`.
 The *inline namespace set* of `N` is the transitive closure of all
+inline namespaces in `N`.
 A *nested-namespace-definition* with an *enclosing-namespace-specifier*
 `E`, *identifier* `I` and *namespace-body* `B` is equivalent to
 ``` cpp
 ```
 where the optional `inline` is present if and only if the *identifier*
 `I` is preceded by `inline`.
+[*Example 2*:
 ``` cpp
 namespace A::inline B::C {
   int i;
 }
 }
 ```
 — *end example*]
 ### Namespace alias <a id="namespace.alias">[[namespace.alias]]</a>
 A *namespace-alias-definition* declares an alternate name for a
 namespace according to the following grammar:
 ``` bnf
 qualified-namespace-specifier:
     nested-name-specifierₒₚₜ namespace-name
 ```
+The *identifier* in a *namespace-alias-definition* becomes a
+*namespace-alias* and denotes the namespace denoted by the
+*qualified-namespace-specifier*.
 [*Note 1*: When looking up a *namespace-name* in a
 *namespace-alias-definition*, only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
 ### Using namespace directive <a id="namespace.udir">[[namespace.udir]]</a>
 ``` bnf
 using-directive:
     attribute-specifier-seqₒₚₜ using namespace nested-name-specifierₒₚₜ namespace-name ';'
 [[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