[namespace.def] - C++14 → C++17

Files changed (1) hide show

tmp/tmpqod1ct_c/{from.md → to.md} +142 -71

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

@@ -1,69 +1,64 @@
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
-The grammar for a *namespace-definition* is
 ``` bnf
 namespace-name:
- original-namespace-name
         namespace-alias
 ```
-``` bnf
-original-namespace-name:
-        identifier
-```
 ``` bnf
 namespace-definition:
         named-namespace-definition
         unnamed-namespace-definition
 ```
 ``` bnf
 named-namespace-definition:
- original-namespace-definition
-        extension-namespace-definition
-```
-``` bnf
-original-namespace-definition:
-        'inline'ₒₚₜ 'namespace' identifier '{' namespace-body '}'
-```
-``` bnf
-extension-namespace-definition:
-        'inline'ₒₚₜ 'namespace' original-namespace-name '{' namespace-body '}'
 ```
 ``` bnf
 unnamed-namespace-definition:
-        'inline'ₒₚₜ 'namespace {' namespace-body '}'
 ```
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
-The *identifier* in an *original-namespace-definition* shall not have
-been previously defined in the declarative region in which the
-*original-namespace-definition* appears. The *identifier* in an
-*original-namespace-definition* is the name of the namespace.
-Subsequently in that declarative region, it is treated as an
-*original-namespace-name*.
-The *original-namespace-name* in an *extension-namespace-definition*
-shall have previously been defined in an *original-namespace-definition*
-in the same declarative region.
 Every *namespace-definition* shall appear in the global scope or in a
 namespace scope ([[basic.scope.namespace]]).
 Because a *namespace-definition* contains *declaration*s in its
 *namespace-body* and a *namespace-definition* is itself a *declaration*,
-it follows that *namespace-definitions* can be nested.
 ``` cpp
 namespace Outer {
   int i;
   namespace Inner {
@@ -72,16 +67,20 @@ namespace Outer {
     void g() { i++; }           // Inner::i
   }
 }
 ```
 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.
 ``` cpp
 namespace Q {
   namespace V {
     void f();                   // enclosing namespaces are the global namespace, Q, and Q::V
     class C { void m(); };
@@ -92,55 +91,94 @@ namespace Q {
   void V::C::m() {              // enclosing namespaces are the global namespace, Q, and Q::V
   }
 }
 ```
 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 an *extension-namespace-definition* only if it was previously used on
-the *original-namespace-definition* for that namespace.
 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 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.
 #### Unnamed namespaces <a id="namespace.unnamed">[[namespace.unnamed]]</a>
 An *unnamed-namespace-definition* behaves as if it were replaced by
 ``` bnf
-'inline'ₒₚₜ 'namespace' unique '{ /* empty body */ }'
-'using namespace' unique ';'
-'namespace' unique '{' namespace-body '}'
 ```
 where `inline` appears if and only if it appears in the
-*unnamed-namespace-definition*, all occurrences of *unique* in a
 translation unit are replaced by the same identifier, and this
-identifier differs from all other identifiers in the entire program.[^5]
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
@@ -158,64 +196,95 @@ void h() {
   A::i++;                       // A::unique ::i
   j++;                          // A::unique ::j
 }
 ```
 #### Namespace member definitions <a id="namespace.memdef">[[namespace.memdef]]</a>
-Members (including explicit specializations of templates (
-[[temp.expl.spec]])) of a namespace can be defined within that
-namespace.
 ``` cpp
 namespace X {
-  void f() { /* ... */ }
 }
 ```
 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.
 ``` 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
 }
 ```
-Every name first declared in a namespace is a member of that namespace.
 If a `friend` declaration in a non-local class first declares a class,
-function, class template or function template[^6] 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]]).
-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). 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.
-The other forms of `friend` declarations cannot declare a new member of
-the innermost enclosing namespace and thus follow the usual lookup
-rules.
 ``` cpp
 // Assume f and g have not yet been declared.
 void h(int);
 template <class T> void f2(T);
@@ -231,12 +300,12 @@ namespace A {
   };
   // 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;
@@ -245,5 +314,7 @@ void h() {
   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
 }
 ```

 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
 ``` bnf
 namespace-name:
+ identifier
         namespace-alias
 ```
 ``` bnf
 namespace-definition:
         named-namespace-definition
         unnamed-namespace-definition
+        nested-namespace-definition
 ```
 ``` bnf
 named-namespace-definition:
+ 'inline'ₒₚₜ 'namespace' attribute-specifier-seqₒₚₜ identifier '{' namespace-body '}'
 ```
 ``` bnf
 unnamed-namespace-definition:
+        'inline'ₒₚₜ 'namespace' attribute-specifier-seqₒₚₜ '{' namespace-body '}'
+```
+``` bnf
+nested-namespace-definition:
+        'namespace' enclosing-namespace-specifier '::' identifier '{' namespace-body '}'
+```
+``` bnf
+enclosing-namespace-specifier:
+        identifier
+        enclosing-namespace-specifier '::' identifier
 ```
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
 Every *namespace-definition* shall appear in the global scope or in a
 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.
+[*Example 1*:
 ``` cpp
 namespace Outer {
   int i;
   namespace Inner {
     void g() { i++; }           // Inner::i
   }
 }
 ```
+— *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::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
+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
+namespace E { namespace I { B } }
+```
+[*Example 3*:
+``` cpp
+namespace A::B::C {
+  int i;
+}
+```
+The above has the same effect as:
+``` cpp
+namespace A {
+  namespace B {
+    namespace C {
+      int i;
+    }
+  }
+}
+```
+— *end example*]
 #### Unnamed namespaces <a id="namespace.unnamed">[[namespace.unnamed]]</a>
 An *unnamed-namespace-definition* behaves as if it were replaced by
 ``` bnf
+'inline'ₒₚₜ 'namespace' 'unique ' '{ /* empty body */ }'
+'using namespace' 'unique ' ';'
+'namespace' 'unique ' '{' namespace-body '}'
 ```
 where `inline` appears if and only if it appears in the
+*unnamed-namespace-definition* and all occurrences of `unique ` in a
 translation unit are replaced by the same identifier, and this
+identifier differs from all other identifiers in the translation unit.
+The optional *attribute-specifier-seq* in the
+*unnamed-namespace-definition* appertains to `unique `.
+[*Example 1*:
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
   A::i++;                       // A::unique ::i
   j++;                          // A::unique ::j
 }
 ```
+— *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* (Clause [[class]]) 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[^5] 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);
   };
   // 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;
   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*]

Diff to HTML by rtfpessoa