[basic.lookup.unqual] - C++20 → C++23

Files changed (1) hide show

tmp/tmp45tv0toy/{from.md → to.md} +94 -280

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

@@ -1,301 +1,115 @@
 ### Unqualified name lookup <a id="basic.lookup.unqual">[[basic.lookup.unqual]]</a>
-In all the cases listed in  [[basic.lookup.unqual]], the scopes are
-searched for a declaration in the order listed in each of the respective
-categories; name lookup ends as soon as a declaration is found for the
-name. If no declaration is found, the program is ill-formed.
-The declarations from the namespace nominated by a *using-directive*
-become visible in a namespace enclosing the *using-directive*; see
-[[namespace.udir]]. For the purpose of the unqualified name lookup rules
-described in  [[basic.lookup.unqual]], the declarations from the
-namespace nominated by the *using-directive* are considered members of
-that enclosing namespace.
-The lookup for an unqualified name used as the *postfix-expression* of a
-function call is described in  [[basic.lookup.argdep]].
-[*Note 1*:
-For purposes of determining (during parsing) whether an expression is a
-*postfix-expression* for a function call, the usual name lookup rules
-apply. In some cases a name followed by `<` is treated as a
-*template-name* even though name lookup did not find a *template-name*
-(see [[temp.names]]). For example,
-``` cpp
-int h;
-void g();
-namespace N {
-  struct A {};
-  template <class T> int f(T);
-  template <class T> int g(T);
-  template <class T> int h(T);
-}
-int x = f<N::A>(N::A());        // OK: lookup of f finds nothing, f treated as template name
-int y = g<N::A>(N::A());        // OK: lookup of g finds a function, g treated as template name
-int z = h<N::A>(N::A());        // error: h< does not begin a template-id
-```
-The rules in  [[basic.lookup.argdep]] have no effect on the syntactic
-interpretation of an expression. For example,
-``` cpp
-typedef int f;
-namespace N {
-  struct A {
-    friend void f(A &);
-    operator int();
-    void g(A a) {
-      int i = f(a);             // f is the typedef, not the friend function: equivalent to int(a)
-    }
-  };
-}
-```
-Because the expression is not a function call, the argument-dependent
-name lookup [[basic.lookup.argdep]] does not apply and the friend
-function `f` is not found.
-— *end note*]
-A name used in global scope, outside of any function, class or
-user-declared namespace, shall be declared before its use in global
-scope.
-A name used in a user-declared namespace outside of the definition of
-any function or class shall be declared before its use in that namespace
-or before its use in a namespace enclosing its namespace.
-In the definition of a function that is a member of namespace `N`, a
-name used after the function’s *declarator-id*[^3] shall be declared
-before its use in the block in which it is used or in one of its
-enclosing blocks [[stmt.block]] or shall be declared before its use in
-namespace `N` or, if `N` is a nested namespace, shall be declared before
-its use in one of `N`’s enclosing namespaces.
 [*Example 1*:
 ``` cpp
-namespace A {
-  namespace N {
-    void f();
- }
-}
-void A::N::f() {
-  i = 5;
-  // The following scopes are searched for a declaration of i:
-  // 1) outermost block scope of A::N::f, before the use of i
-  // 2) scope of namespace N
-  // 3) scope of namespace A
-  // 4) global scope, before the definition of A::N::f
-}
-```
-— *end example*]
-A name used in the definition of a class `X` [^4] outside of a
-complete-class context [[class.mem]] of `X` 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`
-  (this lookup applies in turn to `Y`’s enclosing classes, starting with
-  the innermost enclosing class),[^5] or
-- if `X` is a local class [[class.local]] or is a nested class of a
-  local class, before the definition of class `X` in a block enclosing
-  the definition of class `X`, or
-- if `X` is a member of namespace `N`, or is a nested class of a class
-  that is a member of `N`, or is a local class or a nested class within
-  a local class of a function that is a member of `N`, before the
-  definition of class `X` in namespace `N` or in one of `N`’s enclosing
-  namespaces.
-[*Example 2*:
-``` cpp
-namespace M {
-  class B { };
-}
-```
-``` cpp
-namespace N {
-  class Y : public M::B {
-    class X {
-      int a[i];
-    };
-  };
-}
-// The following scopes are searched for a declaration of i:
-// 1) scope of class N::Y::X, before the use of i
-// 2) scope of class N::Y, before the definition of N::Y::X
-// 3) scope of N::Y's base class M::B
-// 4) scope of namespace N, before the definition of N::Y
-// 5) global scope, before the definition of N
-```
-— *end example*]
-[*Note 2*: When looking for a prior declaration of a class or function
-introduced by a friend declaration, scopes outside of the innermost
-enclosing namespace scope are not considered; see
-[[namespace.memdef]]. — *end note*]
-[*Note 3*:  [[basic.scope.class]] further describes the restrictions on
-the use of 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. — *end note*]
-For the members of a class `X`, a name used in a complete-class context
-[[class.mem]] of `X` or in the definition of a class member outside of
-the definition of `X`, following the member’s *declarator-id*[^6], 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
-- if `X` is a nested class of class `Y` [[class.nest]], shall be a
-  member of `Y`, or shall be a member of a base class of `Y` (this
-  lookup applies in turn to `Y`’s enclosing classes, starting with the
-  innermost enclosing class),[^7] or
-- if `X` is a local class [[class.local]] or is a nested class of a
-  local class, before the definition of class `X` in a block enclosing
-  the definition of class `X`, or
-- if `X` is a member of namespace `N`, or is a nested class of a class
-  that is a member of `N`, or is a local class or a nested class within
-  a local class of a function that is a member of `N`, before the use of
-  the name, in namespace `N` or in one of `N`’s enclosing namespaces.
-[*Example 3*:
-``` cpp
-class B { };
-namespace M {
-  namespace N {
-    class X : public B {
-      void f();
-    };
-  }
-}
-void M::N::X::f() {
-  i = 16;
-}
-// The following scopes are searched for a declaration of i:
-// 1) outermost block scope of M::N::X::f, before the use of i
-// 2) scope of class M::N::X
-// 3) scope of M::N::X's base class B
-// 4) scope of namespace M::N
-// 5) scope of namespace M
-// 6) global scope, before the definition of M::N::X::f
-```
-— *end example*]
-[*Note 4*:  [[class.mfct]] and  [[class.static]] further describe the
-restrictions on the use of names in member function definitions.
-[[class.nest]] further describes the restrictions on the use of names in
-the scope of nested classes. [[class.local]] further describes the
-restrictions on the use of names in local class
-definitions. — *end note*]
-Name lookup for a name used in the definition of a friend function
-[[class.friend]] defined inline in the class granting friendship shall
-proceed as described for lookup in member function definitions. If the
-friend function is not defined in the class granting friendship, name
-lookup in the friend function definition shall proceed as described for
-lookup in namespace member function definitions.
-In a friend declaration naming a member function, a name used in the
-function declarator and not part of a *template-argument* in the
-*declarator-id* is first looked up in the scope of the member function’s
-class [[class.member.lookup]]. If it is not found, or if the name is
-part of a *template-argument* in the *declarator-id*, the look up is as
-described for unqualified names in the definition of the class granting
-friendship.
-[*Example 4*:
-``` cpp
-struct A {
-  typedef int AT;
-  void f1(AT);
-  void f2(float);
-  template <class T> void f3();
-};
 struct B {
- typedef char AT;
- typedef float BT;
- friend void A::f1(AT);        // parameter type is A::AT
- friend void A::f2(BT);        // parameter type is B::BT
- friend void A::f3<AT>();      // template argument is B::AT
 };
 ```
 — *end example*]
-During the lookup for a name used as a default argument
-[[dcl.fct.default]] in a function *parameter-declaration-clause* or used
-in the *expression* of a *mem-initializer* for a constructor
-[[class.base.init]], the function parameter names are visible and hide
-the names of entities declared in the block, class or namespace scopes
-containing the function declaration.
-[*Note 5*:  [[dcl.fct.default]] further describes the restrictions on
-the use of names in default arguments. [[class.base.init]] further
-describes the restrictions on the use of names in a
-*ctor-initializer*. — *end note*]
-During the lookup of a name used in the *constant-expression* of an
-*enumerator-definition*, previously declared *enumerator*s of the
-enumeration are visible and hide the names of entities declared in the
-block, class, or namespace scopes containing the *enum-specifier*.
-A name used in the definition of a `static` data member of class `X`
-[[class.static.data]] (after the *qualified-id* of the static member) is
-looked up as if the name was used in a member function of `X`.
-[*Note 6*:  [[class.static.data]] further describes the restrictions on
-the use of names in the definition of a `static` data
-member. — *end note*]
-If a variable member of a namespace is defined outside of the scope of
-its namespace then any name that appears in the definition of the member
-(after the *declarator-id*) is looked up as if the definition of the
-member occurred in its namespace.
-[*Example 5*:
 ``` cpp
-namespace N {
-  int i = 4;
-  extern int j;
 }
-int i = 2;
-int N::j = i;       // N::j == 4
 ```
 — *end example*]
-A name used in the handler for a *function-try-block* [[except.pre]] is
-looked up as if the name was used in the outermost block of the function
-definition. In particular, the function parameter names shall not be
-redeclared in the *exception-declaration* nor in the outermost block of
-a handler for the *function-try-block*. Names declared in the outermost
-block of the function definition are not found when looked up in the
-scope of a handler for the *function-try-block*.
-[*Note 7*: But function parameter names are found. — *end note*]
-[*Note 8*: The rules for name lookup in template definitions are
-described in  [[temp.res]]. — *end note*]

 ### Unqualified name lookup <a id="basic.lookup.unqual">[[basic.lookup.unqual]]</a>
+A *using-directive* is *active* in a scope S at a program point P if it
+precedes P and inhabits either S or the scope of a namespace nominated
+by a *using-directive* that is active in S at P.
+An *unqualified search* in a scope S from a program point P includes the
+results of searches from P in
+- S, and
+- for any scope U that contains P and is or is contained by S, each
+ namespace contained by S that is nominated by a *using-directive* that
+  is active in U at P.
+If no declarations are found, the results of the unqualified search are
+the results of an unqualified search in the parent scope of S, if any,
+from P.
+[*Note 1*: When a class scope is searched, the scopes of its base
+classes are also searched [[class.member.lookup]]. If it inherits from a
+single base, it is as if the scope of the base immediately contains the
+scope of the derived class. Template parameter scopes that are
+associated with one scope in the chain of parents are also considered
+[[temp.local]]. — *end note*]
+*Unqualified name lookup* from a program point performs an unqualified
+search in its immediate scope.
+An *unqualified name* is a name that does not immediately follow a
+*nested-name-specifier* or the `.` or `->` in a class member access
+expression [[expr.ref]], possibly after a `template` keyword or `~`.
+Unless otherwise specified, such a name undergoes unqualified name
+lookup from the point where it appears.
+An unqualified name that is a component name [[expr.prim.id.unqual]] of
+a *type-specifier* or *ptr-operator* of a *conversion-type-id* is looked
+up in the same fashion as the *conversion-function-id* in which it
+appears. If that lookup finds nothing, it undergoes unqualified name
+lookup; in each case, only names that denote types or templates whose
+specializations are types are considered.
 [*Example 1*:
 ``` cpp
+struct T1 { struct U { int i; }; };
+struct T2 { };
+struct U1 {};
+struct U2 {};
 struct B {
+ using T = T1;
+ using U = U1;
+ operator U1 T1::*();
+ operator U1 T2::*();
+ operator U2 T1::*();
+  operator U2 T2::*();
 };
+template<class X, class T>
+int g() {
+  using U = U2;
+  X().operator U T::*();                // #1, searches for T in the scope of X first
+  X().operator U decltype(T())::*();    // #2
+  return 0;
+}
+int x = g<B, T2>();                     // #1 calls B::operator U1 T1::*
+                                        // #2 calls B::operator U1 T2::*
 ```
 — *end example*]
+In a friend declaration *declarator* whose *declarator-id* is a
+*qualified-id* whose lookup context [[basic.lookup.qual]] is a class or
+namespace S, lookup for an unqualified name that appears after the
+*declarator-id* performs a search in the scope associated with S. If
+that lookup finds nothing, it undergoes unqualified name lookup.
+[*Example 2*:
 ``` cpp
+using I = int;
+using D = double;
+namespace A {
+  inline namespace N {using C = char; }
+  using F = float;
+  void f(I);
+  void f(D);
+  void f(C);
+  void f(F);
+}
+struct X0 {using F = float; };
+struct W {
+  using D = void;
+  struct X : X0 {
+    void g(I);
+    void g(::D);
+    void g(F);
+  };
+};
+namespace B {
+  typedef short I, F;
+  class Y {
+    friend void A::f(I);        // error: no void A::f(short)
+    friend void A::f(D);        // OK
+    friend void A::f(C);        // error: A::N::C not found
+    friend void A::f(F);        // OK
+    friend void W::X::g(I);     // error: no void X::g(short)
+    friend void W::X::g(D);     // OK
+    friend void W::X::g(F);     // OK
+  };
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa