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

Files changed (1) hide show

tmp/tmpt4t8ral9/{from.md → to.md} +413 -202

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

@@ -9,72 +9,67 @@ more translation units.
 The outermost declarative region of a translation unit is a namespace;
 see  [[basic.scope.namespace]].
 ### 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 {
@@ -83,16 +78,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(); };
@@ -103,55 +102,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++
@@ -169,64 +207,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);
@@ -242,12 +311,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;
@@ -256,10 +325,12 @@ 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 alias <a id="namespace.alias">[[namespace.alias]]</a>
 A *namespace-alias-definition* declares an alternate name for a
 namespace according to the following grammar:
@@ -278,57 +349,75 @@ 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*. When looking up a *namespace-name* in a
 *namespace-alias-definition*, only namespace names are considered, see
-[[basic.lookup.udir]].
 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. 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;
 ```
-A *namespace-name* or *namespace-alias* shall not be declared as the
-name of any other entity in the same declarative region. A
-*namespace-name* defined at global scope shall not be declared as the
-name of any other entity in any global scope of the program. No
-diagnostic is required for a violation of this rule by declarations in
-different translation units.
 ### The `using` declaration <a id="namespace.udecl">[[namespace.udecl]]</a>
-A *using-declaration* introduces a name into the declarative region in
-which the *using-declaration* appears.
 ``` bnf
 using-declaration:
-    'using typename'ₒₚₜ nested-name-specifier unqualified-id ';'
-    'using ::' unqualified-id ';'
 ```
-The member name specified in a *using-declaration* is declared in the
-declarative region in which the *using-declaration* appears. Only the
-specified name is so declared; specifying an enumeration name in a
-*using-declaration* does not declare its enumerators in the
-*using-declaration*’s declarative region. If a *using-declaration* names
-a constructor ([[class.qual]]), it implicitly declares a set of
-constructors in the class in which the *using-declaration* appears (
-[[class.inhctor]]); otherwise the name specified in a
-*using-declaration* is a synonym for a set of declarations in another
-namespace or class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
-and so can be used in a class definition.
 ``` cpp
 struct B {
   void f(char);
   void g(char);
@@ -341,16 +430,32 @@ struct D : B {
   void f(int) { f('c'); }       // calls B::f(char)
   void g(int) { g('c'); }       // recursively calls D::g(int)
 };
 ```
-In a *using-declaration* used as a *member-declaration*, the
-*nested-name-specifier* shall name a base class of the class being
-defined. If such a *using-declaration* names a constructor, the
-*nested-name-specifier* shall name a direct base class of the class
-being defined; otherwise it introduces the set of declarations found by
-member name lookup ([[class.member.lookup]],  [[class.qual]]).
 ``` cpp
 class C {
   int g();
 };
@@ -361,25 +466,30 @@ class D2 : public B {
   using B::x;                   // OK: x is a union member of base B
   using C::g;                   // error: C isn't a base of D2
 };
 ```
-Since destructors do not have names, a *using-declaration* cannot refer
-to a destructor for a base class. Since specializations of member
-templates for conversion functions are not found by name lookup, they
-are not considered when a *using-declaration* specifies a conversion
-function ([[temp.mem]]). If an assignment operator brought from a base
-class into a derived class scope has the signature of a copy/move
-assignment operator for the derived class ([[class.copy]]), the
 *using-declaration* does not by itself suppress the implicit declaration
-of the derived class assignment operator; the copy/move assignment
-operator from the base class is hidden or overridden by the
-implicitly-declared copy/move assignment operator of the derived class,
-as described below.
 A *using-declaration* shall not name a *template-id*.
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 };
@@ -387,34 +497,39 @@ struct B : A {
   using A::f<double>;           // ill-formed
   using A::X<int>;              // ill-formed
 };
 ```
 A *using-declaration* shall not name a namespace.
 A *using-declaration* shall not name a scoped enumerator.
-A *using-declaration* for a class member shall be a
 *member-declaration*.
 ``` cpp
 struct X {
   int i;
   static int s;
 };
 void f() {
-  using X::i; // error: X::i is a class member
- // and this is not a member declaration.
-  using X::s;       // error: X::s is a class member
-                    // and this is not a member declaration.
 }
 ```
 Members declared by a *using-declaration* can be referred to by explicit
-qualification just like other member names ([[namespace.qual]]). In a
-*using-declaration*, a prefix `::` refers to the global namespace.
 ``` cpp
 void f();
 namespace A {
@@ -431,78 +546,83 @@ void h()
   X::f();                       // calls ::f
   X::g();                       // calls A::g
 }
 ```
 A *using-declaration* is a *declaration* and can therefore be used
 repeatedly where (and only where) multiple declarations are allowed.
 ``` cpp
 namespace A {
   int i;
 }
 namespace A1 {
-  using A::i;
-  using A::i;       // OK: double declaration
-}
-void f() {
-  using A::i;
-  using A::i;       // error: double declaration
 }
 struct B {
   int i;
 };
 struct X : B {
-  using B::i;
-  using B::i;       // error: double member declaration
 };
 ```
-Members added to the namespace after the *using-declaration* are not
-considered when a use of the name is made. 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.class.spec]],
-[[temp.expl.spec]]) are considered.
 ``` cpp
 namespace A {
   void f(int);
 }
-using A::f;         // f is a synonym for A::f;
-                    // that is, for A::f(int).
 namespace A {
   void f(char);
 }
 void foo() {
-  f('a');           // calls f(int),
-}                   // even though f(char) exists.
 void bar() {
-  using A::f;       // f is a synonym for A::f;
-                    // that is, for A::f(int) and A::f(char).
   f('a');           // calls f(char)
 }
 ```
-Partial specializations of class templates are found by looking up the
-primary class template and then considering all partial specializations
-of that template. If a *using-declaration* names a class template,
-partial specializations introduced after the *using-declaration* are
-effectively visible because the primary template is visible (
-[[temp.class.spec]]).
 Since a *using-declaration* is a declaration, the restrictions on
 declarations of the same name in the same declarative region (
 [[basic.scope]]) also apply to *using-declaration*s.
 ``` cpp
 namespace A {
   int x;
 }
@@ -529,22 +649,29 @@ void func() {
   x = 99;           // assigns to A::x
   struct x x1;      // x1 has class type B::x
 }
 ```
 If a function declaration in namespace scope or block scope has the same
 name and the same parameter-type-list ([[dcl.fct]]) as a function
 introduced by a *using-declaration*, and the declarations do not declare
 the same function, the program is ill-formed. If a function template
 declaration in namespace scope has the same name, parameter-type-list,
 return type, and template parameter list as a function template
-introduced by a *using-declaration*, the program is ill-formed. Two
-*using-declaration*s may introduce functions with the same name and the
-same parameter-type-list. If, for a call to an unqualified function
 name, function overload resolution selects the functions introduced by
 such *using-declaration*s, the function call is ill-formed.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 }
@@ -561,17 +688,23 @@ void h() {
   f(1);             // error: ambiguous: B::f(int) or C::f(int)?
   void f(int);      // error: f(int) conflicts with C::f(int) and B::f(int)
 }
 ```
-When a *using-declaration* brings names from a base class into a derived
-class scope, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
-than conflicting). For *using-declaration*s that name a constructor,
-see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
@@ -595,32 +728,70 @@ void k(D* p)
   p->f(1);          // calls D::f(int)
   p->f('a');        // calls B::f(char)
   p->g(1);          // calls B::g(int)
   p->g('a');        // calls D::g(char)
 }
 ```
-For the purpose of overload resolution, the functions which are
-introduced by a *using-declaration* into a derived class will be treated
-as though they were members of the derived class. In particular, the
 implicit `this` parameter shall be treated as if it were a pointer to
 the derived class rather than to the base class. This has no effect on
 the type of the function, and in all other respects the function remains
-a member of the base class.
-The access rules for inheriting constructors are specified in
-[[class.inhctor]]; otherwise all instances of the name mentioned in a
-*using-declaration* shall be accessible. In particular, if a derived
-class uses a *using-declaration* to access a member of a base class, the
-member name shall be accessible. If the name is that of an overloaded
-member function, then all functions named shall be accessible. The base
-class members mentioned by a *using-declaration* shall be visible in the
-scope of at least one of the direct base classes of the class where the
-*using-declaration* is specified. Because a *using-declaration*
-designates a base class member (and not a member subobject or a member
-function of a base class subobject), a *using-declaration* cannot be
-used to resolve inherited member ambiguities. For example,
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
@@ -631,18 +802,26 @@ struct C : A {
 struct D : B, C {
   using C::x;
   int x(double);
 };
 int f(D* d) {
-  return d->x();    // ambiguous: B::x or C::x
 }
 ```
-The alias created by the *using-declaration* has the usual accessibility
-for a *member-declaration*. A *using-declaration* that names a
-constructor does not create aliases; see  [[class.inhctor]] for the
-pertinent accessibility rules.
 ``` cpp
 class A {
 private:
     void f(char);
@@ -657,11 +836,13 @@ class B : public A {
 public:
   using A::g;       // B::g is a public synonym for A::g
 };
 ```
-If a *using-declaration* uses the keyword `typename` and specifies a
 dependent name ([[temp.dep]]), the name introduced by the
 *using-declaration* is treated as a *typedef-name* ([[dcl.typedef]]).
 ### Using directive <a id="namespace.udir">[[namespace.udir]]</a>
@@ -669,26 +850,34 @@ dependent name ([[temp.dep]]), the name introduced by the
 using-directive:
     attribute-specifier-seqₒₚₜ 'using namespace' nested-name-specifierₒₚₜ namespace-name ';'
 ```
 A *using-directive* shall not appear in class scope, but may appear in
-namespace scope or in block scope. When looking up a *namespace-name* in
-a *using-directive*, only namespace names are considered, see
-[[basic.lookup.udir]]. 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. In this context,
-“contains” means “contains directly or indirectly”.
 A *using-directive* does not add any members to the declarative region
 in which it appears.
 ``` cpp
 namespace A {
   int i;
   namespace B {
     namespace C {
@@ -713,15 +902,22 @@ namespace A {
 void f4() {
   i = 5;            // ill-formed; neither i is visible
 }
 ```
 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. For qualified lookup, see  [[namespace.qual]].
 ``` cpp
 namespace M {
   int i;
 }
@@ -760,21 +956,27 @@ namespace B {
     int n = j;      // D::j hides B::j
   }
 }
 ```
-If a namespace is extended by an *extension-namespace-definition* 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 *extension-namespace-definition* can be used
-after the *extension-namespace-definition*.
 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, the use of the name is ill-formed. In particular,
-the name of a variable, function or enumerator does not hide the name of
-a class or enumeration declared in a different namespace. For example,
 ``` cpp
 namespace A {
   class X { };
   extern "C"   int g();
@@ -788,24 +990,31 @@ namespace B {
 using namespace A;
 using namespace B;
 void f() {
   X(1);             // error: name X found in two namespaces
-  g();              // okay: name g refers to the same entity
-  h();              // okay: overload resolution selects A::h
 }
 ```
 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. 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. 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.[^7]
 ``` cpp
 namespace D {
   int d1;
   void f(char);
@@ -834,5 +1043,7 @@ void f() {
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
   f('a');           // OK: D::f(char)
 }
 ```

 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
 ```
 ``` 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*]
 ### 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:
     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*]
 ### The `using` declaration <a id="namespace.udecl">[[namespace.udecl]]</a>
 ``` bnf
 using-declaration:
+    'using' using-declarator-list ';'
 ```
+``` bnf
+using-declarator-list:
+    using-declarator '...'ₒₚₜ
+ using-declarator-list ',' using-declarator '...'ₒₚₜ
+```
+``` bnf
+using-declarator:
+    'typename'ₒₚₜ nested-name-specifier unqualified-id
+```
+Each *using-declarator* in a *using-declaration* [^6] introduces a set
+of declarations into the declarative region in which the
+*using-declaration* appears. The set of declarations introduced by the
+*using-declarator* is found by performing qualified name lookup (
+[[basic.lookup.qual]], [[class.member.lookup]]) for the name in the
+*using-declarator*, excluding functions that are hidden as described
+below. If the *using-declarator* does not name a constructor, the
+*unqualified-id* is declared in the declarative region in which the
+*using-declaration* appears as a synonym for each declaration introduced
+by the *using-declarator*.
+[*Note 1*: Only the specified name is so declared; specifying an
+enumeration name in a *using-declaration* does not declare its
+enumerators in the *using-declaration*'s declarative
+region. — *end note*]
+If the *using-declarator* names a constructor, it declares that the
+class *inherits* the set of constructor declarations introduced by the
+*using-declarator* from the nominated base class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
+and can therefore be used in a class definition.
+[*Example 1*:
 ``` cpp
 struct B {
   void f(char);
   void g(char);
   void f(int) { f('c'); }       // calls B::f(char)
   void g(int) { g('c'); }       // recursively calls D::g(int)
 };
 ```
+— *end example*]
+In a *using-declaration* used as a *member-declaration*, each
+*using-declarator*'s *nested-name-specifier* shall name a base class of
+the class being defined. If a *using-declarator* names a constructor,
+its *nested-name-specifier* shall name a direct base class of the class
+being defined.
+[*Example 2*:
+``` cpp
+template <typename... bases>
+struct X : bases... {
+  using bases::g...;
+};
+X<B, D> x;                      // OK: B::g and D::g introduced
+```
+— *end example*]
+[*Example 3*:
 ``` cpp
 class C {
   int g();
 };
   using B::x;                   // OK: x is a union member of base B
   using C::g;                   // error: C isn't a base of D2
 };
 ```
+— *end example*]
+[*Note 2*: Since destructors do not have names, a *using-declaration*
+cannot refer to a destructor for a base class. Since specializations of
+member templates for conversion functions are not found by name lookup,
+they are not considered when a *using-declaration* specifies a
+conversion function ([[temp.mem]]). — *end note*]
+If a constructor or assignment operator brought from a base class into a
+derived class has the signature of a copy/move constructor or assignment
+operator for the derived class ([[class.copy]]), the
 *using-declaration* does not by itself suppress the implicit declaration
+of the derived class member; the member from the base class is hidden or
+overridden by the implicitly-declared copy/move constructor or
+assignment operator of the derived class, as described below.
 A *using-declaration* shall not name a *template-id*.
+[*Example 4*:
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 };
   using A::f<double>;           // ill-formed
   using A::X<int>;              // ill-formed
 };
 ```
+— *end example*]
 A *using-declaration* shall not name a namespace.
 A *using-declaration* shall not name a scoped enumerator.
+A *using-declaration* that names a class member shall be a
 *member-declaration*.
+[*Example 5*:
 ``` cpp
 struct X {
   int i;
   static int s;
 };
 void f() {
+  using X::i; // error: X::i is a class member and this is not a member declaration.
+  using X::s;                   // error: X::s is a class member and this is not a member declaration.
 }
 ```
+— *end example*]
 Members declared by a *using-declaration* can be referred to by explicit
+qualification just like other member names ([[namespace.qual]]).
+[*Example 6*:
 ``` cpp
 void f();
 namespace A {
   X::f();                       // calls ::f
   X::g();                       // calls A::g
 }
 ```
+— *end example*]
 A *using-declaration* is a *declaration* and can therefore be used
 repeatedly where (and only where) multiple declarations are allowed.
+[*Example 7*:
 ``` cpp
 namespace A {
   int i;
 }
 namespace A1 {
+  using A::i, A::i;             // OK: double declaration
 }
 struct B {
   int i;
 };
 struct X : B {
+  using B::i, B::i;             // error: double member declaration
 };
 ```
+— *end example*]
+[*Note 3*: For a *using-declaration* whose *nested-name-specifier*
+names a namespace, members added to the namespace after the
+*using-declaration* are not in the set of introduced declarations, so
+they are not considered when a use of the name is made. 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.class.spec]],
+[[temp.expl.spec]]) are considered. — *end note*]
+[*Example 8*:
 ``` cpp
 namespace A {
   void f(int);
 }
+using A::f;         // f is a synonym for A::f; that is, for A::f(int).
 namespace A {
   void f(char);
 }
 void foo() {
+  f('a');           // calls f(int), even though f(char) exists.
+}
 void bar() {
+  using A::f;       // f is a synonym for A::f; that is, for A::f(int) and A::f(char).
   f('a');           // calls f(char)
 }
 ```
+— *end example*]
+[*Note 4*: Partial specializations of class templates are found by
+looking up the primary class template and then considering all partial
+specializations of that template. If a *using-declaration* names a class
+template, partial specializations introduced after the
+*using-declaration* are effectively visible because the primary template
+is visible ([[temp.class.spec]]). — *end note*]
 Since a *using-declaration* is a declaration, the restrictions on
 declarations of the same name in the same declarative region (
 [[basic.scope]]) also apply to *using-declaration*s.
+[*Example 9*:
 ``` cpp
 namespace A {
   int x;
 }
   x = 99;           // assigns to A::x
   struct x x1;      // x1 has class type B::x
 }
 ```
+— *end example*]
 If a function declaration in namespace scope or block scope has the same
 name and the same parameter-type-list ([[dcl.fct]]) as a function
 introduced by a *using-declaration*, and the declarations do not declare
 the same function, the program is ill-formed. If a function template
 declaration in namespace scope has the same name, parameter-type-list,
 return type, and template parameter list as a function template
+introduced by a *using-declaration*, the program is ill-formed.
+[*Note 5*:
+Two *using-declaration*s may introduce functions with the same name and
+the same parameter-type-list. If, for a call to an unqualified function
 name, function overload resolution selects the functions introduced by
 such *using-declaration*s, the function call is ill-formed.
+[*Example 10*:
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 }
   f(1);             // error: ambiguous: B::f(int) or C::f(int)?
   void f(int);      // error: f(int) conflicts with C::f(int) and B::f(int)
 }
 ```
+— *end example*]
+— *end note*]
+When a *using-declarator* brings declarations from a base class into a
+derived class, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
+than conflicting). Such hidden or overridden declarations are excluded
+from the set of declarations introduced by the *using-declarator*.
+[*Example 11*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
   p->f(1);          // calls D::f(int)
   p->f('a');        // calls B::f(char)
   p->g(1);          // calls B::g(int)
   p->g('a');        // calls D::g(char)
 }
+struct B1 {
+  B1(int);
+};
+struct B2 {
+  B2(int);
+};
+struct D1 : B1, B2 {
+  using B1::B1;
+  using B2::B2;
+};
+D1 d1(0);           // ill-formed: ambiguous
+struct D2 : B1, B2 {
+  using B1::B1;
+  using B2::B2;
+  D2(int);          // OK: D2::D2(int) hides B1::B1(int) and B2::B2(int)
+};
+D2 d2(0);           // calls D2::D2(int)
 ```
+— *end example*]
+For the purpose of overload resolution, the functions that are
+introduced by a *using-declaration* into a derived class are treated as
+though they were members of the derived class. In particular, the
 implicit `this` parameter shall be treated as if it were a pointer to
 the derived class rather than to the base class. This has no effect on
 the type of the function, and in all other respects the function remains
+a member of the base class. Likewise, constructors that are introduced
+by a *using-declaration* are treated as though they were constructors of
+the derived class when looking up the constructors of the derived
+class ([[class.qual]]) or forming a set of overload candidates (
+[[over.match.ctor]], [[over.match.copy]], [[over.match.list]]). If such
+a constructor is selected to perform the initialization of an object of
+class type, all subobjects other than the base class from which the
+constructor originated are implicitly initialized (
+[[class.inhctor.init]]).
+In a *using-declarator* that does not name a constructor, all members of
+the set of introduced declarations shall be accessible. In a
+*using-declarator* that names a constructor, no access check is
+performed. In particular, if a derived class uses a *using-declarator*
+to access a member of a base class, the member name shall be accessible.
+If the name is that of an overloaded member function, then all functions
+named shall be accessible. The base class members mentioned by a
+*using-declarator* shall be visible in the scope of at least one of the
+direct base classes of the class where the *using-declarator* is
+specified.
+[*Note 6*:
+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 12*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
 struct D : B, C {
   using C::x;
   int x(double);
 };
 int f(D* d) {
+  return d->x();    // error: overload resolution selects A::x, but A is an ambiguous base class
 }
 ```
+— *end example*]
+— *end note*]
+A synonym created by a *using-declaration* has the usual accessibility
+for a *member-declaration*. A *using-declarator* that names a
+constructor does not create a synonym; instead, the additional
+constructors are accessible if they would be accessible when used to
+construct an object of the corresponding base class, and the
+accessibility of the *using-declaration* is ignored.
+[*Example 13*:
 ``` cpp
 class A {
 private:
     void f(char);
 public:
   using A::g;       // B::g is a public synonym for A::g
 };
 ```
+— *end example*]
+If a *using-declarator* uses the keyword `typename` and specifies a
 dependent name ([[temp.dep]]), the name introduced by the
 *using-declaration* is treated as a *typedef-name* ([[dcl.typedef]]).
 ### Using directive <a id="namespace.udir">[[namespace.udir]]</a>
 using-directive:
     attribute-specifier-seqₒₚₜ 'using namespace' nested-name-specifierₒₚₜ namespace-name ';'
 ```
 A *using-directive* shall not appear in class scope, but may appear in
+namespace scope or in block scope.
+[*Note 1*: When looking up a *namespace-name* in a *using-directive*,
+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 {
   int i;
   namespace B {
     namespace C {
 void f4() {
   i = 5;            // ill-formed; neither i is visible
 }
 ```
+— *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 {
   int i;
 }
     int n = j;      // D::j hides B::j
   }
 }
 ```
+— *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*.
 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, the use of the name is ill-formed.
+[*Note 4*:
+In particular, the name of a variable, function or enumerator does not
+hide the name of a class or enumeration declared in a different
+namespace. For example,
 ``` cpp
 namespace A {
   class X { };
   extern "C"   int g();
 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.[^7]
+[*Example 3*:
 ``` cpp
 namespace D {
   int d1;
   void f(char);
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
   f('a');           // OK: D::f(char)
 }
 ```
+— *end example*]

Diff to HTML by rtfpessoa