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

Files changed (1) hide show

tmp/tmp0zsgm6gm/{from.md → to.md} +129 -110

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

@@ -1,15 +1,19 @@
 ### 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).
 [*Example 1*:
 ``` cpp
 namespace N {
@@ -17,132 +21,125 @@ namespace N {
   void f(S);
 }
 void g() {
   N::S s;
-  f(s);             // OK: calls N::f
   (f)(s);           // error: N::f not considered; parentheses prevent argument-dependent lookup
 }
 ```
 — *end example*]
 For each argument type `T` in the function call, there is a set of zero
-or more *associated namespaces* and a set of zero or more *associated
-entities* (other than namespaces) to be considered. The sets of
-namespaces and entities are determined entirely by the types of the
-function arguments (and the namespace of any template template
-argument). Typedef names and *using-declaration*s used to specify the
-types do not contribute to this set. The sets of namespaces and entities
-are determined in the following way:
-- If `T` is a fundamental type, its associated sets of namespaces and
-  entities are both empty.
 - If `T` is a class type (including unions), its associated entities
   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 entities.
- Furthermore, if `T` is a class template specialization, its associated
- namespaces and entities also include: the namespaces and entities
- associated with the types of the template arguments provided for
-  template type parameters (excluding template template parameters); the
- templates used as template template arguments; 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.
- \[*Note 1*: Non-type template arguments do not contribute to the set
-  of associated namespaces. — *end note*]
-- If `T` is an enumeration type, its associated namespace is the
-  innermost enclosing namespace of its declaration, and its associated
- entities are `T` and, if it is a class member, the member’s class.
-- If `T` is a pointer to `U` or an array of `U`, its associated
-  namespaces and entities are those associated with `U`.
-- If `T` is a function type, its associated namespaces and entities are
-  those associated with the function parameter types and those
-  associated with the return type.
 - If `T` is a pointer to a member function of a class `X`, its
-  associated namespaces and entities are those associated with the
- function parameter types and return type, together with those
-  associated with `X`.
 - If `T` is a pointer to a data member of class `X`, its associated
- namespaces and entities are those associated with the member type
- together with those associated with `X`.
-If an associated namespace is an inline namespace [[namespace.def]], its
-enclosing namespace is also included in the set. If an associated
-namespace directly contains inline namespaces, those inline namespaces
-are also included in the set. In addition, if the argument is the name
-or address of an overload set, its associated entities and namespaces
-are the union of those associated with each of the members of the set,
-i.e., the entities and namespaces associated with its parameter types
-and return type. Additionally, if the aforementioned overload set is
-named with a *template-id*, its associated entities and namespaces also
-include those of its type *template-argument*s and its template
-*template-argument*s.
-Let *X* be the lookup set produced by unqualified lookup
-[[basic.lookup.unqual]] and let *Y* be the lookup set produced by
-argument dependent lookup (defined as follows). If *X* contains
-- a declaration of a class member, or
-- a block-scope function declaration that is not a *using-declaration*,
-  or
-- a declaration that is neither a function nor a function template
-then *Y* is empty. Otherwise *Y* is the set of declarations found in the
-namespaces associated with the argument types as described below. The
-set of declarations found by the lookup of the name is the union of *X*
-and *Y*.
-[*Note 2*: The namespaces and entities associated with the argument
-types can include namespaces and entities already considered by the
-ordinary unqualified lookup. — *end note*]
 [*Example 2*:
-``` cpp
-namespace NS {
-  class T { };
-  void f(T);
-  void g(T, int);
-}
-NS::T parm;
-void g(NS::T, float);
-int main() {
-  f(parm);                      // OK: calls NS::f
-  extern void g(NS::T, float);
-  g(parm, 1);                   // OK: calls g(NS::T, float)
-}
-```
-— *end example*]
-When considering an associated namespace `N`, the lookup is the same as
-the lookup performed when `N` is used as a qualifier [[namespace.qual]]
-except that:
-- Any *using-directive*s in `N` are ignored.
-- All names except those of (possibly overloaded) functions and function
-  templates are ignored.
-- Any namespace-scope friend functions or friend function templates
-  [[class.friend]] declared in classes with reachable definitions in the
-  set of associated entities are visible within their respective
-  namespaces even if they are not visible during an ordinary lookup
-  [[namespace.memdef]].
-- Any exported declaration `D` in `N` declared within the purview of a
-  named module `M` [[module.interface]] is visible if there is an
-  associated entity attached to `M` with the same innermost enclosing
-  non-inline namespace as `D`.
-- If the lookup is for a dependent name ([[temp.dep]],
-  [[temp.dep.candidate]]), any declaration `D` in `N` is visible if `D`
-  would be visible to qualified name lookup [[namespace.qual]] at any
-  point in the instantiation context [[module.context]] of the lookup,
-  unless `D` is declared in another translation unit, attached to the
-  global module, and is either discarded [[module.global.frag]] or has
-  internal linkage.
-[*Example 3*:
 Translation unit #1
 ``` cpp
 export module M;
 namespace R {
@@ -186,5 +183,27 @@ void test() {
 }
 ```
 — *end example*]

 ### 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*, and unqualified lookup [[basic.lookup.unqual]] for the
+name in the *unqualified-id* does not find any
+- declaration of a class member, or
+- function declaration inhabiting a block scope, or
+- declaration not of a function or function template
+then lookup for the name also includes the result of
+*argument-dependent lookup* in a set of associated namespaces that
+depends on the types of the arguments (and for template template
+arguments, the namespace of the template argument), as specified below.
 [*Example 1*:
 ``` cpp
 namespace N {
   void f(S);
 }
 void g() {
   N::S s;
+  f(s);             // OK, calls N::f
   (f)(s);           // error: N::f not considered; parentheses prevent argument-dependent lookup
 }
 ```
 — *end example*]
+[*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 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, argument-dependent name
+lookup does not apply and the friend function `f` is not found.
+— *end note*]
 For each argument type `T` in the function call, there is a set of zero
+or more *associated entities* to be considered. The set of entities is
+determined entirely by the types of the function arguments (and any
+template template arguments). Any *typedef-name*s and
+*using-declaration*s used to specify the types do not contribute to this
+set. The set of entities is determined in the following way:
+- If `T` is a fundamental type, its associated set of entities is empty.
 - If `T` is a class type (including unions), its associated entities
   are: the class itself; the class of which it is a member, if any; and
+  its direct and indirect base classes. Furthermore, if `T` is a class
+ template specialization, its associated entities also include: the
+ entities associated with the types of the template arguments provided
+ for template type parameters; the templates used as template template
+ arguments; and the classes of which any member templates used as
+  template template arguments are members. \[*Note 2*: Non-type template
+ arguments do not contribute to the set of associated
+ entities. — *end note*]
+- If `T` is an enumeration type, its associated entities are `T` and, if
+ it is a class member, the member’s class.
+- If `T` is a pointer to `U` or an array of `U`, its associated entities
+  are those associated with `U`.
+- If `T` is a function type, its associated entities are those
+ associated with the function parameter types and those associated with
+  the return type.
 - If `T` is a pointer to a member function of a class `X`, its
+  associated entities are those associated with the function parameter
+  types and return type, together with those associated with `X`.
 - If `T` is a pointer to a data member of class `X`, its associated
+  entities are those associated with the member type together with those
+  associated with `X`.
+In addition, if the argument is an overload set or the address of such a
+set, its associated entities are the union of those associated with each
+of the members of the set, i.e., the entities associated with its
+parameter types and return type. Additionally, if the aforementioned
+overload set is named with a *template-id*, its associated entities also
+include its template *template-argument*s and those associated with its
+type *template-argument*s.
+The *associated namespaces* for a call are the innermost enclosing
+non-inline namespaces for its associated entities as well as every
+element of the inline namespace set [[namespace.def]] of those
+namespaces. Argument-dependent lookup finds all declarations of
+functions and function templates that
+- are found by a search of any associated namespace, or
+- are declared as a friend [[class.friend]] of any class with a
+ reachable definition in the set of associated entities, or
+- are exported, are attached to a named module `M` [[module.interface]],
+  do not appear in the translation unit containing the point of the
+  lookup, and have the same innermost enclosing non-inline namespace
+  scope as a declaration of an associated entity attached to `M`
+  [[basic.link]].
+If the lookup is for a dependent name
+[[temp.dep]], [[temp.dep.candidate]], the above lookup is also performed
+from each point in the instantiation context [[module.context]] of the
+lookup, additionally ignoring any declaration that appears in another
+translation unit, is attached to the global module, and is either
+discarded [[module.global.frag]] or has internal linkage.
 [*Example 2*:
 Translation unit #1
 ``` cpp
 export module M;
 namespace R {
 }
 ```
 — *end example*]
+[*Note 3*: The associated namespace can include namespaces already
+considered by ordinary unqualified lookup. — *end note*]
+[*Example 3*:
+``` cpp
+namespace NS {
+  class T { };
+  void f(T);
+  void g(T, int);
+}
+NS::T parm;
+void g(NS::T, float);
+int main() {
+  f(parm);                      // OK, calls NS::f
+  extern void g(NS::T, float);
+  g(parm, 1);                   // OK, calls g(NS::T, float)
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa