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

Files changed (1) hide show

tmp/tmpe_sej0ox/{from.md → to.md} +18 -163

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

@@ -1,7 +1,9 @@
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
 ``` bnf
 namespace-name:
         identifier
         namespace-alias
 ```
@@ -37,22 +39,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.
@@ -69,34 +69,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
@@ -104,33 +80,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
@@ -138,11 +111,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;
 }
@@ -201,123 +174,5 @@ 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 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*]

Diff to HTML by rtfpessoa