[basic.lookup] - C++11 → C++14

Files changed (1) hide show

tmp/tmpd3zc9o6f/{from.md → to.md} +23 -22

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

@@ -98,12 +98,13 @@ void A::N::f() {
   // 4) global scope, before the definition of A::N::f
 }
 ```
 A name used in the definition of a class `X` outside of a member
-function body or nested class definition[^5] shall be declared in one of
-the following ways:
 - before its use in class `X` or be a member of a base class of `X` (
   [[class.member.lookup]]), or
 - if `X` is a nested class of class `Y` ([[class.nest]]), before the
   definition of `X` in `Y`, or shall be a member of a base class of `Y`
@@ -148,15 +149,16 @@ namespace scope are not considered; see  [[namespace.memdef]].
 names in a class definition. [[class.nest]] further describes the
 restrictions on the use of names in nested class definitions.
 [[class.local]] further describes the restrictions on the use of names
 in local class definitions.
-A name used in the definition of a member function ([[class.mfct]]) of
-class `X` following the function’s *declarator-id*[^7] or in the
 *brace-or-equal-initializer* of a non-static data member (
-[[class.mem]]) of class `X` shall be declared in one of the following
-ways:
 - before its use in the block in which it is used or in an enclosing
   block ([[stmt.block]]), or
 - shall be a member of class `X` or be a member of a base class of `X` (
   [[class.member.lookup]]), or
@@ -283,14 +285,14 @@ The rules for name lookup in template definitions are described in
 ### Argument-dependent name lookup <a id="basic.lookup.argdep">[[basic.lookup.argdep]]</a>
 When the *postfix-expression* in a function call ([[expr.call]]) is an
 *unqualified-id*, other namespaces not considered during the usual
 unqualified lookup ([[basic.lookup.unqual]]) may be searched, and in
-those namespaces, namespace-scope friend function declarations (
-[[class.friend]]) not otherwise visible may be found. These
-modifications to the search depend on the types of the arguments (and
-for template template arguments, the namespace of the template
 argument).
 ``` cpp
 namespace N {
   struct S { };
@@ -317,23 +319,23 @@ way:
 - If `T` is a fundamental type, its associated sets of namespaces and
   classes are both empty.
 - If `T` is a class type (including unions), its associated classes are:
   the class itself; the class of which it is a member, if any; and its
   direct and indirect base classes. Its associated namespaces are the
-  namespaces of which its associated classes are members. Furthermore,
   if `T` is a class template specialization, its associated namespaces
   and classes also include: the namespaces and classes associated with
   the types of the template arguments provided for template type
   parameters (excluding template template parameters); the namespaces of
   which any template template arguments are members; and the classes of
   which any member templates used as template template arguments are
   members. Non-type template arguments do not contribute to the set of
   associated namespaces.
 - If `T` is an enumeration type, its associated namespace is the
- namespace in which it is defined. If it is class member, its
-  associated class is the member’s class; else it has no associated
-  class.
 - If `T` is a pointer to `U` or an array of `U`, its associated
   namespaces and classes are those associated with `U`.
 - If `T` is a function type, its associated namespaces and classes are
   those associated with the function parameter types and those
   associated with the return type.
@@ -510,12 +512,12 @@ lookup rule above are the following:
   the context in which the entire *postfix-expression* occurs.
 - the lookup for a name specified in a *using-declaration* (
   [[namespace.udecl]]) also finds class or enumeration names hidden
   within the same scope ([[basic.scope.hiding]]).
-In a lookup in which the constructor is an acceptable lookup result and
-the *nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
   up in `C`, is the injected-class-name of `C` (Clause  [[class]]), or
 - in a *using-declaration* ([[namespace.udecl]]) that is a
   *member-declaration*, if the name specified after the
@@ -851,16 +853,15 @@ If the *id-expression* in a class member access ([[expr.ref]]) is an
 *unqualified-id*, and the type of the object expression is of a class
 type `C`, the *unqualified-id* is looked up in the scope of class `C`.
 For a pseudo-destructor call ([[expr.pseudo]]), the *unqualified-id* is
 looked up in the context of the complete *postfix-expression*.
-If the *unqualified-id* is *\textasciitilde{}type-name*, the *type-name*
-is looked up in the context of the entire *postfix-expression*. If the
-type `T` of the object expression is of a class type `C`, the
-*type-name* is also looked up in the scope of class `C`. At least one of
-the lookups shall find a name that refers to (possibly cv-qualified)
-`T`.
 ``` cpp
 struct A { };
 struct B {

   // 4) global scope, before the definition of A::N::f
 }
 ```
 A name used in the definition of a class `X` outside of a member
+function body, default argument, *exception-specification*,
+*brace-or-equal-initializer* of a non-static data member, or nested
+class definition[^5] shall be declared in one of the following ways:
 - before its use in class `X` or be a member of a base class of `X` (
   [[class.member.lookup]]), or
 - if `X` is a nested class of class `Y` ([[class.nest]]), before the
   definition of `X` in `Y`, or shall be a member of a base class of `Y`
 names in a class definition. [[class.nest]] further describes the
 restrictions on the use of names in nested class definitions.
 [[class.local]] further describes the restrictions on the use of names
 in local class definitions.
+For the members of a class `X`, a name used in a member function body,
+in a default argument, in an *exception-specification*, in the
 *brace-or-equal-initializer* of a non-static data member (
+[[class.mem]]), or in the definition of a class member outside of the
+definition of `X`, following the member’s *declarator-id*[^7], shall be
+declared in one of the following ways:
 - before its use in the block in which it is used or in an enclosing
   block ([[stmt.block]]), or
 - shall be a member of class `X` or be a member of a base class of `X` (
   [[class.member.lookup]]), or
 ### Argument-dependent name lookup <a id="basic.lookup.argdep">[[basic.lookup.argdep]]</a>
 When the *postfix-expression* in a function call ([[expr.call]]) is an
 *unqualified-id*, other namespaces not considered during the usual
 unqualified lookup ([[basic.lookup.unqual]]) may be searched, and in
+those namespaces, namespace-scope friend function or function template
+declarations ([[class.friend]]) not otherwise visible may be found.
+These modifications to the search depend on the types of the arguments
+(and for template template arguments, the namespace of the template
 argument).
 ``` cpp
 namespace N {
   struct S { };
 - If `T` is a fundamental type, its associated sets of namespaces and
   classes are both empty.
 - If `T` is a class type (including unions), its associated classes are:
   the class itself; the class of which it is a member, if any; and its
   direct and indirect base classes. Its associated namespaces are the
+ innermost enclosing namespaces of its associated classes. Furthermore,
   if `T` is a class template specialization, its associated namespaces
   and classes also include: the namespaces and classes associated with
   the types of the template arguments provided for template type
   parameters (excluding template template parameters); the namespaces of
   which any template template arguments are members; and the classes of
   which any member templates used as template template arguments are
   members. Non-type template arguments do not contribute to the set of
   associated namespaces.
 - If `T` is an enumeration type, its associated namespace is the
+ innermost enclosing namespace of its declaration. If it is a class
+ member, its associated class is the member’s class; else it has no
+ associated class.
 - If `T` is a pointer to `U` or an array of `U`, its associated
   namespaces and classes are those associated with `U`.
 - If `T` is a function type, its associated namespaces and classes are
   those associated with the function parameter types and those
   associated with the return type.
   the context in which the entire *postfix-expression* occurs.
 - the lookup for a name specified in a *using-declaration* (
   [[namespace.udecl]]) also finds class or enumeration names hidden
   within the same scope ([[basic.scope.hiding]]).
+In a lookup in which function names are not ignored[^9] and the
+*nested-name-specifier* nominates a class `C`:
 - if the name specified after the *nested-name-specifier*, when looked
   up in `C`, is the injected-class-name of `C` (Clause  [[class]]), or
 - in a *using-declaration* ([[namespace.udecl]]) that is a
   *member-declaration*, if the name specified after the
 *unqualified-id*, and the type of the object expression is of a class
 type `C`, the *unqualified-id* is looked up in the scope of class `C`.
 For a pseudo-destructor call ([[expr.pseudo]]), the *unqualified-id* is
 looked up in the context of the complete *postfix-expression*.
+If the *unqualified-id* is `~`*type-name*, the *type-name* is looked up
+in the context of the entire *postfix-expression*. If the type `T` of
+the object expression is of a class type `C`, the *type-name* is also
+looked up in the scope of class `C`. At least one of the lookups shall
+find a name that refers to (possibly cv-qualified) `T`.
 ``` cpp
 struct A { };
 struct B {

Diff to HTML by rtfpessoa