[temp.dep.res] - C++17 → C++20

Files changed (1) hide show

tmp/tmp2e9hvt_o/{from.md → to.md} +222 -32

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

@@ -1,16 +1,7 @@
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
-In resolving dependent names, names from the following sources are
-considered:
-- Declarations that are visible at the point of definition of the
-  template.
-- Declarations from namespaces associated with the types of the function
-  arguments both from the instantiation context ([[temp.point]]) and
-  from the definition context.
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
 For a function template specialization, a member function template
 specialization, or a specialization for a member function or static data
 member of a class template, if the specialization is implicitly
@@ -56,44 +47,243 @@ enclosing class template specialization.
 An explicit instantiation definition is an instantiation point for the
 specialization or specializations specified by the explicit
 instantiation.
-The instantiation context of an expression that depends on the template
-arguments is the set of declarations with external linkage declared
-prior to the point of instantiation of the template specialization in
-the same translation unit.
 A specialization for a function template, a member function template, or
 of a member function or static data member of a class template may have
 multiple points of instantiations within a translation unit, and in
-addition to the points of instantiation described above, for any such
-specialization that has a point of instantiation within the translation
-unit, the end of the translation unit is also considered a point of
-instantiation. A specialization for a class template has at most one
-point of instantiation within a translation unit. A specialization for
-any template may have points of instantiation in multiple translation
-units. If two different points of instantiation give a template
-specialization different meanings according to the one-definition rule (
-[[basic.def.odr]]), the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 For a function call where the *postfix-expression* is a dependent name,
-the candidate functions are found using the usual lookup rules (
-[[basic.lookup.unqual]], [[basic.lookup.argdep]]) except that:
-- For the part of the lookup using unqualified name lookup (
- [[basic.lookup.unqual]]), only function declarations from the template
-  definition context are found.
-- For the part of the lookup using associated namespaces (
-  [[basic.lookup.argdep]]), only function declarations found in either
-  the template definition context or the template instantiation context
-  are found.
 If the call would be ill-formed or would find a better match had the
 lookup within the associated namespaces considered all the function
 declarations with external linkage introduced in those namespaces in all
 translation units, not just considering those declarations found in the
 template definition and template instantiation contexts, then the
 program has undefined behavior.

 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
 For a function template specialization, a member function template
 specialization, or a specialization for a member function or static data
 member of a class template, if the specialization is implicitly
 An explicit instantiation definition is an instantiation point for the
 specialization or specializations specified by the explicit
 instantiation.
 A specialization for a function template, a member function template, or
 of a member function or static data member of a class template may have
 multiple points of instantiations within a translation unit, and in
+addition to the points of instantiation described above,
+- for any such specialization that has a point of instantiation within
+  the *declaration-seq* of the *translation-unit*, prior to the
+  *private-module-fragment* (if any), the point after the
+  *declaration-seq* of the *translation-unit* is also considered a point
+ of instantiation, and
+- for any such specialization that has a point of instantiation within
+  the *private-module-fragment*, the end of the translation unit is also
+  considered a point of instantiation.
+A specialization for a class template has at most one point of
+instantiation within a translation unit. A specialization for any
+template may have points of instantiation in multiple translation units.
+If two different points of instantiation give a template specialization
+different meanings according to the one-definition rule
+[[basic.def.odr]], the program is ill-formed, no diagnostic required.
 #### Candidate functions <a id="temp.dep.candidate">[[temp.dep.candidate]]</a>
 For a function call where the *postfix-expression* is a dependent name,
+the candidate functions are found using the usual lookup rules from the
+template definition context ([[basic.lookup.unqual]],
+[[basic.lookup.argdep]]).
+[*Note 1*: For the part of the lookup using associated namespaces
+[[basic.lookup.argdep]], function declarations found in the template
+instantiation context are found by this lookup, as described in
+[[basic.lookup.argdep]]. — *end note*]
 If the call would be ill-formed or would find a better match had the
 lookup within the associated namespaces considered all the function
 declarations with external linkage introduced in those namespaces in all
 translation units, not just considering those declarations found in the
 template definition and template instantiation contexts, then the
 program has undefined behavior.
+[*Example 1*:
+Source file \`"X.h"\`
+``` cpp
+namespace Q {
+  struct X { };
+}
+```
+Source file \`"G.h"\`
+``` cpp
+namespace Q {
+  void g_impl(X, X);
+}
+```
+Module interface unit of \`M1\`
+``` cpp
+module;
+#include "X.h"
+#include "G.h"
+export module M1;
+export template<typename T>
+void g(T t) {
+  g_impl(t, Q::X{ });   // ADL in definition context finds Q::g_impl, g_impl not discarded
+}
+```
+Module interface unit of \`M2\`
+``` cpp
+module;
+#include "X.h"
+export module M2;
+import M1;
+void h(Q::X x) {
+   g(x);                // OK
+}
+```
+— *end example*]
+[*Example 2*:
+Module interface unit of \`Std\`
+``` cpp
+export module Std;
+export template<typename Iter>
+void indirect_swap(Iter lhs, Iter rhs)
+{
+  swap(*lhs, *rhs);     // swap not found by unqualified lookup, can be found only via ADL
+}
+```
+Module interface unit of \`M\`
+``` cpp
+export module M;
+import Std;
+struct S { /* ...*/ };
+void swap(S&, S&);      // #1
+void f(S* p, S* q)
+{
+  indirect_swap(p, q);  // finds #1 via ADL in instantiation context
+}
+```
+— *end example*]
+[*Example 3*:
+Source file \`"X.h"\`
+``` cpp
+struct X { /* ... */ };
+X operator+(X, X);
+```
+Module interface unit of \`F\`
+``` cpp
+export module F;
+export template<typename T>
+void f(T t) {
+  t + t;
+}
+```
+Module interface unit of \`M\`
+``` cpp
+module;
+#include "X.h"
+export module M;
+import F;
+void g(X x) {
+  f(x);             // OK: instantiates f from F,
+                    // operator+ is visible in instantiation context
+}
+```
+— *end example*]
+[*Example 4*:
+Module interface unit of \`A\`
+``` cpp
+export module A;
+export template<typename T>
+void f(T t) {
+  cat(t, t);            // #1
+  dog(t, t);            // #2
+}
+```
+Module interface unit of \`B\`
+``` cpp
+export module B;
+import A;
+export template<typename T, typename U>
+void g(T t, U u) {
+  f(t);
+}
+```
+Source file \`"foo.h"\`, not an importable header
+``` cpp
+struct foo {
+  friend int cat(foo, foo);
+};
+int dog(foo, foo);
+```
+Module interface unit of \`C1\`
+``` cpp
+module;
+#include "foo.h"        // dog not referenced, discarded
+export module C1;
+import B;
+export template<typename T>
+void h(T t) {
+  g(foo{ }, t);
+}
+```
+Translation unit
+``` cpp
+import C1;
+void i() {
+   h(0);                // error: dog not found at #2
+}
+```
+Importable header \`"bar.h"\`
+``` cpp
+struct bar {
+  friend int cat(bar, bar);
+};
+int dog(bar, bar);
+```
+Module interface unit of \`C2\`
+``` cpp
+module;
+#include "bar.h"        // imports header unit "bar.h"
+export module C2;
+import B;
+export template<typename T>
+void j(T t) {
+  g(bar{ }, t);
+}
+```
+Translation unit
+``` cpp
+import C2;
+void k() {
+   j(0);                // OK, dog found in instantiation context:
+                        // visible at end of module interface unit of C2
+}
+```
+— *end example*]

Diff to HTML by rtfpessoa