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

Files changed (1) hide show

tmp/tmpo5wq8ed_/{from.md → to.md} +470 -176

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

@@ -2,11 +2,11 @@
 Three kinds of names can be used within a template definition:
 - The name of the template itself, and names declared within the
   template itself.
-- Names dependent on a *template-parameter* ([[temp.dep]]).
 - Names from scopes which are visible within the template definition.
 A name used in a template declaration or definition and that is
 dependent on a *template-parameter* is assumed not to name a type unless
 the applicable name lookup finds a type name or the name is qualified by
@@ -28,38 +28,31 @@ template<class T> class Y {
     Y* a3;                      // declare pointer to Y<T>
     Z* a4;                      // declare pointer to Z
     typedef typename T::A TA;
     TA* a5;                     // declare pointer to T's A
     typename T::A* a6;          // declare pointer to T's A
-    T::A* a7;                   // T::A is not a type name:
-                                // multiplication of T::A by a7; ill-formed, no visible declaration of a7
-    B* a8;                      // B is not a type name:
-                                // multiplication of B by a8; ill-formed, no visible declarations of B and a8
   }
 };
 ```
 — *end example*]
-When a *qualified-id* is intended to refer to a type that is not a
-member of the current instantiation ([[temp.dep.type]]) and its
-*nested-name-specifier* refers to a dependent type, it shall be prefixed
-by the keyword `typename`, forming a *typename-specifier*. If the
-*qualified-id* in a *typename-specifier* does not denote a type or a
-class template, the program is ill-formed.
 ``` bnf
 typename-specifier:
- 'typename' nested-name-specifier identifier
- 'typename' nested-name-specifier 'template'ₒₚₜ simple-template-id
 ```
-If a specialization of a template is instantiated for a set of
-*template-argument*s such that the *qualified-id* prefixed by `typename`
-does not denote a type or a class template, the specialization is
-ill-formed. The usual qualified name lookup ([[basic.lookup.qual]]) is
-used to find the *qualified-id* even in the presence of `typename`.
 [*Example 2*:
 ``` cpp
 struct A {
@@ -80,33 +73,75 @@ void foo() {
 }
 ```
 — *end example*]
-A qualified name used as the name in a *class-or-decltype* (Clause
-[[class.derived]]) or an *elaborated-type-specifier* is implicitly
 assumed to name a type, without the use of the `typename` keyword. In a
 *nested-name-specifier* that immediately contains a
 *nested-name-specifier* that depends on a template parameter, the
 *identifier* or *simple-template-id* is implicitly assumed to name a
 type, without the use of the `typename` keyword.
 [*Note 1*: The `typename` keyword is not permitted by the syntax of
 these constructs. — *end note*]
-If, for a given set of template arguments, a specialization of a
-template is instantiated that refers to a *qualified-id* that denotes a
-type or a class template, and the *qualified-id* refers to a member of
-an unknown specialization, the *qualified-id* shall either be prefixed
-by `typename` or shall be used in a context in which it implicitly names
-a type as described above.
 [*Example 3*:
 ``` cpp
 template <class T> void f(int i) {
-  T::x * i;         // T::x must not be a type
 }
 struct Foo {
   typedef int x;
 };
@@ -123,38 +158,36 @@ int main() {
 — *end example*]
 Within the definition of a class template or within the definition of a
 member of a class template following the *declarator-id*, the keyword
-`typename` is not required when referring to the name of a previously
-declared member of the class template that declares a type or a class
-template.
-[*Note 2*: Such names can be found using unqualified name lookup (
-[[basic.lookup.unqual]]), class member lookup ([[class.qual]]) into the
-current instantiation ([[temp.dep.type]]), or class member access
-expression lookup ([[basic.lookup.classref]]) when the type of the
-object expression is the current instantiation (
-[[temp.dep.expr]]). — *end note*]
-[*Example 4*:
 ``` cpp
 template<class T> struct A {
   typedef int B;
   B b;              // OK, no typename required
 };
 ```
 — *end example*]
-Knowing which names are type names allows the syntax of every template
-to be checked. The program is ill-formed, no diagnostic required, if:
 - no valid specialization can be generated for a template or a
-  substatement of a constexpr if statement ([[stmt.if]]) within a
- template and the template is not instantiated, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
 - a hypothetical instantiation of a template immediately following its
   definition would be ill-formed due to a construct that does not depend
   on a template parameter, or
@@ -172,13 +205,13 @@ to be checked. The program is ill-formed, no diagnostic required, if:
     *using-declaration* was a pack expansion and the corresponding pack
     is empty, or
   - an instantiation uses a default argument or default template
     argument that had not been defined at the point at which the
     template was defined, or
-  - constant expression evaluation ([[expr.const]]) within the template
     instantiation uses
-    - the value of a `const` object of integral or unscoped enumeration
       type or
     - the value of a `constexpr` object or
     - the value of a reference or
     - the definition of a constexpr function,
@@ -194,15 +227,14 @@ to be checked. The program is ill-formed, no diagnostic required, if:
 Otherwise, no diagnostic shall be issued for a template for which a
 valid specialization can be generated.
 [*Note 4*: If a template is instantiated, errors will be diagnosed
-according to the other rules in this International Standard. Exactly
-when these errors are diagnosed is a quality of implementation
-issue. — *end note*]
-[*Example 5*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
@@ -226,13 +258,13 @@ template<class... T> struct A : T...,  T... { };    // error: duplicate base cla
 When looking for the declaration of a name used in a template
 definition, the usual lookup rules ([[basic.lookup.unqual]],
 [[basic.lookup.argdep]]) are used for non-dependent names. The lookup of
 names dependent on the template parameters is postponed until the actual
-template argument is known ([[temp.dep]]).
-[*Example 6*:
 ``` cpp
 #include <iostream>
 using namespace std;
@@ -247,30 +279,30 @@ public:
       cout << p[i] << '\n';
   }
 };
 ```
-in the example, `i` is the local variable `i` declared in `printall`,
 `cnt` is the member `cnt` declared in `Set`, and `cout` is the standard
 output stream declared in `iostream`. However, not every declaration can
 be found this way; the resolution of some names must be postponed until
 the actual *template-argument*s are known. For example, even though the
 name `operator<<` is known within the definition of `printall()` and a
 declaration of it can be found in `<iostream>`, the actual declaration
 of `operator<<` needed to print `p[i]` cannot be known until it is known
-what type `T` is ([[temp.dep]]).
 — *end example*]
 If a name does not depend on a *template-parameter* (as defined in
 [[temp.dep]]), a declaration (or set of declarations) for that name
 shall be in scope at the point where the name appears in the template
 definition; the name is bound to the declaration (or declarations) found
 at that point and this binding is not affected by declarations that are
 visible at the point of instantiation.
-[*Example 7*:
 ``` cpp
 void f(char);
 template<class T> void g(T t) {
@@ -293,23 +325,24 @@ void h() {
 — *end example*]
 [*Note 5*: For purposes of name lookup, default arguments and
 *noexcept-specifier*s of function templates and default arguments and
 *noexcept-specifier*s of member functions of class templates are
-considered definitions ([[temp.decls]]). — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
-injected-class-name (Clause  [[class]]). The injected-class-name can be
-used as a *template-name* or a *type-name*. When it is used with a
 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
-refers to the class template itself. Otherwise, it is equivalent to the
-*template-name* followed by the *template-parameter*s of the class
-template enclosed in `<>`.
 Within the scope of a class template specialization or partial
 specialization, when the injected-class-name is used as a *type-name*,
 it is equivalent to the *template-name* followed by the
 *template-argument*s of the class template specialization or partial
@@ -331,11 +364,11 @@ template<> class Y<int> {
 ```
 — *end example*]
 The injected-class-name of a class template or class template
-specialization can be used either as a *template-name* or a *type-name*
 wherever it is in scope.
 [*Example 2*:
 ``` cpp
@@ -346,20 +379,20 @@ template <class T> struct Base {
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
 template<class T, template<class> class U = T::template Base> struct Third { };
-Third<Base<int> > t; // OK: default argument uses injected-class-name as a template
 ```
 — *end example*]
-A lookup that finds an injected-class-name ([[class.member.lookup]])
-can result in an ambiguity in certain cases (for example, if it is found
-in more than one base class). If all of the injected-class-names that
-are found refer to specializations of the same class template, and if
-the name is used as a *template-name*, the reference refers to the class
 template itself and not a specialization thereof, and is not ambiguous.
 [*Example 3*:
 ``` cpp
@@ -388,13 +421,13 @@ template<class T> class X {
 };
 ```
 — *end example*]
-A *template-parameter* shall not be redeclared within its scope
-(including nested scopes). A *template-parameter* shall not have the
-same name as the template name.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
@@ -457,14 +490,14 @@ template<class C> void N::B<C>::f(C) {
 — *end example*]
 In the definition of a class template or in the definition of a member
 of such a template that appears outside of the template definition, for
-each non-dependent base class ([[temp.dep.type]]), if the name of the
-base class or the name of a member of the base class is the same as the
-name of a *template-parameter*, the base class name or member name hides
-the *template-parameter* name ([[basic.scope.hiding]]).
 [*Example 8*:
 ``` cpp
 struct A {
@@ -486,31 +519,38 @@ template<class B, class a> struct X : A {
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
-names. An expressions may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
-when evaluated as a constant expression ([[expr.const]]) may depend on
-a template parameter) as described in this subclause. In an expression
-of the form:
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
-- any of the expressions in the *expression-list* is a pack expansion (
-  [[temp.variadic]]),
 - any of the expressions or *braced-init-list*s in the *expression-list*
-  is type-dependent ([[temp.dep.expr]]), or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
-operator also denotes a dependent name. Such names are unbound and are
-looked up at the point of the template instantiation ([[temp.point]])
-in both the context of the template definition and the context of the
-point of instantiation.
 [*Example 1*:
 ``` cpp
 template<class T> struct X : B<T> {
@@ -520,17 +560,17 @@ template<class T> struct X : B<T> {
     pb->j++;
   }
 };
 ```
-the base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
 In the definition of a class or class template, the scope of a dependent
-base class ([[temp.dep.type]]) is not examined during unqualified name
 lookup either at the point of definition of the class template or member
 or during an instantiation of the class template or member.
 [*Example 2*:
@@ -580,41 +620,50 @@ not affect the binding of names in `Y<A>`.
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
-  of a class template, the injected-class-name (Clause  [[class]]) of
- the class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
   template argument list of the primary template (as described below)
   enclosed in `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
   or
 - in the definition of a partial specialization or a member of a partial
   specialization, the name of the class template followed by the
   template argument list of the partial specialization enclosed in `<>`
-  (or an equivalent template alias specialization). If the *n*th
- template parameter is a parameter pack, the *n*th template argument is
- a pack expansion ([[temp.variadic]]) whose pattern is the name of the
-  parameter pack.
 The template argument list of a primary template is a template argument
-list in which the *n*th template argument has the value of the *n*th
-template parameter of the class template. If the *n*th template
-parameter is a template parameter pack ([[temp.variadic]]), the *n*th
-template argument is a pack expansion ([[temp.variadic]]) whose pattern
-is the name of the template parameter pack.
-A template argument that is equivalent to a template parameter (i.e.,
-has the same constant value or the same type as the template parameter)
-can be used in place of that template parameter in a reference to the
-current instantiation. In the case of a non-type template argument, the
-argument must have been given the value of the template parameter and
-not an expression in which the template parameter appears as a
-subexpression.
 [*Example 1*:
 ``` cpp
 template <class T> class A {
@@ -639,22 +688,26 @@ template <class T1, class T2, int I> struct B {
   B<T2, T1, I>* b2;             // not the current instantiation
   typedef T1 my_T1;
   static const int my_I = I;
   static const int my_I2 = I+0;
   static const int my_I3 = my_I;
   B<my_T1, T2, my_I>* b3;       // refers to the current instantiation
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
 };
 ```
 — *end example*]
 A *dependent base class* is a base class that is a dependent type and is
 not the current instantiation.
-[*Note 1*:
 A base class can be the current instantiation in the case of a nested
 class naming an enclosing class as a base.
 [*Example 2*:
@@ -679,26 +732,26 @@ template<class T> struct A<T>::B::C : A<T> {
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 2*: This can only occur when looking up a
   name in a scope enclosed by the definition of a class
   template. — *end note*]
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
-  base class thereof. \[*Note 3*: If no such member is found, and the
   current instantiation has any dependent base classes, then the
   *qualified-id* is a member of an unknown specialization; see
   below. — *end note*]
 - An *id-expression* denoting the member in a class member access
-  expression ([[expr.ref]]) for which the type of the object expression
- is the current instantiation, and the *id-expression*, when looked
- up ([[basic.lookup.classref]]), refers to at least one member of a
- class that is the current instantiation or a non-dependent base class
-  thereof. \[*Note 4*: If no such member is found, and the current
   instantiation has any dependent base classes, then the *id-expression*
   is a member of an unknown specialization; see below. — *end note*]
 [*Example 3*:
@@ -730,18 +783,18 @@ A name is a *member of an unknown specialization* if it is
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
   find any member of a class that is the current instantiation or a
   non-dependent base class thereof.
 - An *id-expression* denoting the member in a class member access
-  expression ([[expr.ref]]) in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
     name lookup of the *id-expression* does not find a member of a class
     that is the current instantiation or a non-dependent base class
     thereof; or
-  - the type of the object expression is dependent and is not the
- current instantiation.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
 member of an unknown specialization, the program is ill-formed even if
 the template containing the *qualified-id* is not instantiated; no
@@ -808,20 +861,20 @@ A type is dependent if it is
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose exception specification is value-dependent,
-- a *simple-template-id* in which either the template name is a template
-  parameter or any of the template arguments is a dependent type or an
-  expression that is type-dependent or value-dependent or is a pack
-  expansion \[*Note 5*: This includes an injected-class-name (Clause
-  [[class]]) of a class template used without a
   *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
-  type-dependent ([[temp.dep.expr]]).
-[*Note 6*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
@@ -830,49 +883,77 @@ Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
 `this`
 is type-dependent if the class type of the enclosing member function is
-dependent ([[temp.dep.type]]).
-An *id-expression* is type-dependent if it contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - an *identifier* associated by name lookup with a non-type
   *template-parameter* declared with a type that contains a placeholder
-  type ([[dcl.spec.auto]]),
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
   with a return type that contains a placeholder type,
 - an *identifier* associated by name lookup with a structured binding
-  declaration ([[dcl.struct.bind]]) whose *brace-or-equal-initializer*
- is type-dependent,
-- the *identifier* `__func__` ([[dcl.fct.def.general]]), where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
 or if it names a dependent member of the current instantiation that is a
-static data member of type “array of unknown bound of `T`” for some
-`T` ([[temp.static]]). Expressions of the following forms are
-type-dependent only if the type specified by the *type-id*,
-*simple-type-specifier* or *new-type-id* is dependent, even if any
-subexpression is type-dependent:
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
-A class member access expression ([[expr.ref]]) is type-dependent if
-the expression refers to a member of the current instantiation and the
-type of the referenced member is dependent, or the class member access
 expression refers to a member of an unknown specialization.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to a
@@ -892,37 +973,60 @@ Except as described below, an expression used in a context where a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
 An *id-expression* is value-dependent if:
 - it is type-dependent,
 - it is the name of a non-type template parameter,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
-- it is a constant with literal type and is initialized with an
-  expression that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
 Expressions of the following form are value-dependent:
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
-expression ([[expr.const]]) succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
@@ -966,19 +1070,10 @@ void g(int);        // not in scope at the point of the template definition, not
 — *end example*]
 ### 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
@@ -1024,61 +1119,260 @@ 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.
 ### Friend names declared within a class template <a id="temp.inject">[[temp.inject]]</a>
 Friend classes or functions can be declared within a class template.
 When a template is instantiated, the names of its friends are treated as
 if the specialization had been explicitly declared at its point of
 instantiation.
 As with non-template classes, the names of namespace-scope friend
 functions of a class template specialization are not visible during an
-ordinary lookup unless explicitly declared at namespace scope (
-[[class.friend]]). Such names may be found under the rules for
-associated classes ([[basic.lookup.argdep]]).[^6]
 [*Example 1*:
 ``` cpp
 template<typename T> struct number {
@@ -1088,11 +1382,11 @@ template<typename T> struct number {
 void g() {
   number<double> a(3), b(4);
   a = gcd(a,b);     // finds gcd because number<double> is an associated class,
                     // making gcd visible in its namespace (global scope)
-  b = gcd(3,4);     // ill-formed; gcd is not visible
 }
 ```
 — *end example*]

 Three kinds of names can be used within a template definition:
 - The name of the template itself, and names declared within the
   template itself.
+- Names dependent on a *template-parameter* [[temp.dep]].
 - Names from scopes which are visible within the template definition.
 A name used in a template declaration or definition and that is
 dependent on a *template-parameter* is assumed not to name a type unless
 the applicable name lookup finds a type name or the name is qualified by
     Y* a3;                      // declare pointer to Y<T>
     Z* a4;                      // declare pointer to Z
     typedef typename T::A TA;
     TA* a5;                     // declare pointer to T's A
     typename T::A* a6;          // declare pointer to T's A
+    T::A* a7;                   // error: no visible declaration of a7
+                                // T::A is not a type name; multiplication of T::A by a7
+    B* a8;                      // error: no visible declarations of B and a8
+                                // B is not a type name; multiplication of B by a8
   }
 };
 ```
 — *end example*]
 ``` bnf
 typename-specifier:
+  typename nested-name-specifier identifier
+  typename nested-name-specifier 'templateₒₚₜ ' simple-template-id
 ```
+A *typename-specifier* denotes the type or class template denoted by the
+*simple-type-specifier* [[dcl.type.simple]] formed by omitting the
+keyword `typename`. The usual qualified name lookup
+[[basic.lookup.qual]] is used to find the *qualified-id* even in the
+presence of `typename`.
 [*Example 2*:
 ``` cpp
 struct A {
 }
 ```
 — *end example*]
+A qualified name used as the name in a *class-or-decltype*
+[[class.derived]] or an *elaborated-type-specifier* is implicitly
 assumed to name a type, without the use of the `typename` keyword. In a
 *nested-name-specifier* that immediately contains a
 *nested-name-specifier* that depends on a template parameter, the
 *identifier* or *simple-template-id* is implicitly assumed to name a
 type, without the use of the `typename` keyword.
 [*Note 1*: The `typename` keyword is not permitted by the syntax of
 these constructs. — *end note*]
+A *qualified-id* is assumed to name a type if
+- it is a qualified name in a type-id-only context (see below), or
+- it is a *decl-specifier* of the *decl-specifier-seq* of a
+  - *simple-declaration* or a *function-definition* in namespace scope,
+  - *member-declaration*,
+  - *parameter-declaration* in a *member-declaration* [^10], unless that
+    *parameter-declaration* appears in a default argument,
+  - *parameter-declaration* in a *declarator* of a function or function
+    template declaration whose *declarator-id* is qualified, unless that
+    *parameter-declaration* appears in a default argument,
+  - *parameter-declaration* in a *lambda-declarator* or
+    *requirement-parameter-list*, unless that *parameter-declaration*
+    appears in a default argument, or
+  - *parameter-declaration* of a (non-type) *template-parameter*.
+A qualified name is said to be in a *type-id-only context* if it appears
+in a *type-id*, *new-type-id*, or *defining-type-id* and the smallest
+enclosing *type-id*, *new-type-id*, or *defining-type-id* is a
+*new-type-id*, *defining-type-id*, *trailing-return-type*, default
+argument of a *type-parameter* of a template, or *type-id* of a
+`static_cast`, `const_cast`, `reinterpret_cast`, or `dynamic_cast`.
 [*Example 3*:
+``` cpp
+template<class T> T::R f();             // OK, return type of a function declaration at global scope
+template<class T> void f(T::R);         // ill-formed, no diagnostic required: attempt to declare
+                                        // a void variable template
+template<class T> struct S {
+  using Ptr = PtrTraits<T>::Ptr;        // OK, in a defining-type-id
+  T::R f(T::P p) {                      // OK, class scope
+    return static_cast<T::R>(p);        // OK, type-id of a static_cast
+  }
+  auto g() -> S<T*>::Ptr;               // OK, trailing-return-type
+};
+template<typename T> void f() {
+  void (*pf)(T::X);                     // variable pf of type void* initialized with T::X
+  void g(T::X);                         // error: T::X at block scope does not denote a type
+                                        // (attempt to declare a void variable)
+}
+```
+— *end example*]
+A *qualified-id* that refers to a member of an unknown specialization,
+that is not prefixed by `typename`, and that is not otherwise assumed to
+name a type (see above) denotes a non-type.
+[*Example 4*:
 ``` cpp
 template <class T> void f(int i) {
+  T::x * i;         // expression, not the declaration of a variable i
 }
 struct Foo {
   typedef int x;
 };
 — *end example*]
 Within the definition of a class template or within the definition of a
 member of a class template following the *declarator-id*, the keyword
+`typename` is not required when referring to a member of the current
+instantiation [[temp.dep.type]].
+[*Example 5*:
 ``` cpp
 template<class T> struct A {
   typedef int B;
   B b;              // OK, no typename required
 };
 ```
 — *end example*]
+The validity of a template may be checked prior to any instantiation.
+[*Note 2*: Knowing which names are type names allows the syntax of
+every template to be checked in this way. — *end note*]
+The program is ill-formed, no diagnostic required, if:
 - no valid specialization can be generated for a template or a
+  substatement of a constexpr if statement [[stmt.if]] within a template
+  and the template is not instantiated, or
+- no substitution of template arguments into a *type-constraint* or
+  *requires-clause* would result in a valid expression, or
 - every valid specialization of a variadic template requires an empty
   template parameter pack, or
 - a hypothetical instantiation of a template immediately following its
   definition would be ill-formed due to a construct that does not depend
   on a template parameter, or
     *using-declaration* was a pack expansion and the corresponding pack
     is empty, or
   - an instantiation uses a default argument or default template
     argument that had not been defined at the point at which the
     template was defined, or
+  - constant expression evaluation [[expr.const]] within the template
     instantiation uses
+    - the value of a const object of integral or unscoped enumeration
       type or
     - the value of a `constexpr` object or
     - the value of a reference or
     - the definition of a constexpr function,
 Otherwise, no diagnostic shall be issued for a template for which a
 valid specialization can be generated.
 [*Note 4*: If a template is instantiated, errors will be diagnosed
+according to the other rules in this document. Exactly when these errors
+are diagnosed is a quality of implementation issue. — *end note*]
+[*Example 6*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
 When looking for the declaration of a name used in a template
 definition, the usual lookup rules ([[basic.lookup.unqual]],
 [[basic.lookup.argdep]]) are used for non-dependent names. The lookup of
 names dependent on the template parameters is postponed until the actual
+template argument is known [[temp.dep]].
+[*Example 7*:
 ``` cpp
 #include <iostream>
 using namespace std;
       cout << p[i] << '\n';
   }
 };
 ```
+In the example, `i` is the local variable `i` declared in `printall`,
 `cnt` is the member `cnt` declared in `Set`, and `cout` is the standard
 output stream declared in `iostream`. However, not every declaration can
 be found this way; the resolution of some names must be postponed until
 the actual *template-argument*s are known. For example, even though the
 name `operator<<` is known within the definition of `printall()` and a
 declaration of it can be found in `<iostream>`, the actual declaration
 of `operator<<` needed to print `p[i]` cannot be known until it is known
+what type `T` is [[temp.dep]].
 — *end example*]
 If a name does not depend on a *template-parameter* (as defined in
 [[temp.dep]]), a declaration (or set of declarations) for that name
 shall be in scope at the point where the name appears in the template
 definition; the name is bound to the declaration (or declarations) found
 at that point and this binding is not affected by declarations that are
 visible at the point of instantiation.
+[*Example 8*:
 ``` cpp
 void f(char);
 template<class T> void g(T t) {
 — *end example*]
 [*Note 5*: For purposes of name lookup, default arguments and
 *noexcept-specifier*s of function templates and default arguments and
 *noexcept-specifier*s of member functions of class templates are
+considered definitions [[temp.decls]]. — *end note*]
 ### Locally declared names <a id="temp.local">[[temp.local]]</a>
 Like normal (non-template) classes, class templates have an
+injected-class-name [[class.pre]]. The injected-class-name can be used
+as a *template-name* or a *type-name*. When it is used with a
 *template-argument-list*, as a *template-argument* for a template
 *template-parameter*, or as the final identifier in the
 *elaborated-type-specifier* of a friend class template declaration, it
+is a *template-name* that refers to the class template itself.
+Otherwise, it is a *type-name* equivalent to the *template-name*
+followed by the *template-parameter*s of the class template enclosed in
+`<>`.
 Within the scope of a class template specialization or partial
 specialization, when the injected-class-name is used as a *type-name*,
 it is equivalent to the *template-name* followed by the
 *template-argument*s of the class template specialization or partial
 ```
 — *end example*]
 The injected-class-name of a class template or class template
+specialization can be used as either a *template-name* or a *type-name*
 wherever it is in scope.
 [*Example 2*:
 ``` cpp
 template <class T> struct Derived: public Base<T> {
   typename Derived::Base* p;            // meaning Derived::Base<T>
 };
 template<class T, template<class> class U = T::template Base> struct Third { };
+Third<Derived<int> > t; // OK: default argument uses injected-class-name as a template
 ```
 — *end example*]
+A lookup that finds an injected-class-name [[class.member.lookup]] can
+result in an ambiguity in certain cases (for example, if it is found in
+more than one base class). If all of the injected-class-names that are
+found refer to specializations of the same class template, and if the
+name is used as a *template-name*, the reference refers to the class
 template itself and not a specialization thereof, and is not ambiguous.
 [*Example 3*:
 ``` cpp
 };
 ```
 — *end example*]
+The name of a *template-parameter* shall not be redeclared within its
+scope (including nested scopes). A *template-parameter* shall not have
+the same name as the template name.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
 — *end example*]
 In the definition of a class template or in the definition of a member
 of such a template that appears outside of the template definition, for
+each non-dependent base class [[temp.dep.type]], if the name of the base
+class or the name of a member of the base class is the same as the name
+of a *template-parameter*, the base class name or member name hides the
+*template-parameter* name [[basic.scope.hiding]].
 [*Example 8*:
 ``` cpp
 struct A {
 Inside a template, some constructs have semantics which may differ from
 one instantiation to another. Such a construct *depends* on the template
 parameters. In particular, types and expressions may depend on the type
 and/or value of template parameters (as determined by the template
 arguments) and this determines the context for name lookup for certain
+names. An expression may be *type-dependent* (that is, its type may
 depend on a template parameter) or *value-dependent* (that is, its value
+when evaluated as a constant expression [[expr.const]] may depend on a
+template parameter) as described in this subclause.
+In an expression of the form:
+``` bnf
+postfix-expression '(' expression-listₒₚₜ ')'
+```
 where the *postfix-expression* is an *unqualified-id*, the
 *unqualified-id* denotes a *dependent name* if
+- any of the expressions in the *expression-list* is a pack expansion
+  [[temp.variadic]],
 - any of the expressions or *braced-init-list*s in the *expression-list*
+  is type-dependent [[temp.dep.expr]], or
 - the *unqualified-id* is a *template-id* in which any of the template
   arguments depends on a template parameter.
 If an operand of an operator is a type-dependent expression, the
+operator also denotes a dependent name.
+[*Note 1*: Such names are unbound and are looked up at the point of the
+template instantiation [[temp.point]] in both the context of the
+template definition and the context of the point of instantiation
+[[temp.dep.candidate]]. — *end note*]
 [*Example 1*:
 ``` cpp
 template<class T> struct X : B<T> {
     pb->j++;
   }
 };
 ```
+The base class name `B<T>`, the type name `T::A`, the names `B<T>::i`
 and `pb->j` explicitly depend on the *template-parameter*.
 — *end example*]
 In the definition of a class or class template, the scope of a dependent
+base class [[temp.dep.type]] is not examined during unqualified name
 lookup either at the point of definition of the class template or member
 or during an instantiation of the class template or member.
 [*Example 2*:
 A name refers to the *current instantiation* if it is
 - in the definition of a class template, a nested class of a class
   template, a member of a class template, or a member of a nested class
+  of a class template, the injected-class-name [[class.pre]] of the
+  class template or nested class,
 - in the definition of a primary class template or a member of a primary
   class template, the name of the class template followed by the
   template argument list of the primary template (as described below)
   enclosed in `<>` (or an equivalent template alias specialization),
 - in the definition of a nested class of a class template, the name of
   the nested class referenced as a member of the current instantiation,
   or
 - in the definition of a partial specialization or a member of a partial
   specialization, the name of the class template followed by the
   template argument list of the partial specialization enclosed in `<>`
+  (or an equivalent template alias specialization). If the nᵗʰ template
+  parameter is a template parameter pack, the nᵗʰ template argument is a
+  pack expansion [[temp.variadic]] whose pattern is the name of the
+ template parameter pack.
 The template argument list of a primary template is a template argument
+list in which the nᵗʰ template argument has the value of the nᵗʰ
+template parameter of the class template. If the nᵗʰ template parameter
+is a template parameter pack [[temp.variadic]], the nᵗʰ template
+argument is a pack expansion [[temp.variadic]] whose pattern is the name
+of the template parameter pack.
+A template argument that is equivalent to a template parameter can be
+used in place of that template parameter in a reference to the current
+instantiation. For a template *type-parameter*, a template argument is
+equivalent to a template parameter if it denotes the same type. For a
+non-type template parameter, a template argument is equivalent to a
+template parameter if it is an *identifier* that names a variable that
+is equivalent to the template parameter. A variable is equivalent to a
+template parameter if
+- it has the same type as the template parameter (ignoring
+  cv-qualification) and
+- its initializer consists of a single *identifier* that names the
+  template parameter or, recursively, such a variable.
+[*Note 1*: Using a parenthesized variable name breaks the
+equivalence. — *end note*]
 [*Example 1*:
 ``` cpp
 template <class T> class A {
   B<T2, T1, I>* b2;             // not the current instantiation
   typedef T1 my_T1;
   static const int my_I = I;
   static const int my_I2 = I+0;
   static const int my_I3 = my_I;
+  static const long my_I4 = I;
+  static const int my_I5 = (I);
   B<my_T1, T2, my_I>* b3;       // refers to the current instantiation
   B<my_T1, T2, my_I2>* b4;      // not the current instantiation
   B<my_T1, T2, my_I3>* b5;      // refers to the current instantiation
+  B<my_T1, T2, my_I4>* b6;      // not the current instantiation
+  B<my_T1, T2, my_I5>* b7;      // not the current instantiation
 };
 ```
 — *end example*]
 A *dependent base class* is a base class that is a dependent type and is
 not the current instantiation.
+[*Note 2*:
 A base class can be the current instantiation in the case of a nested
 class naming an enclosing class as a base.
 [*Example 2*:
 A name is a *member of the current instantiation* if it is
 - An unqualified name that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 3*: This can only occur when looking up a
   name in a scope enclosed by the definition of a class
   template. — *end note*]
 - A *qualified-id* in which the *nested-name-specifier* refers to the
   current instantiation and that, when looked up, refers to at least one
   member of a class that is the current instantiation or a non-dependent
+  base class thereof. \[*Note 4*: If no such member is found, and the
   current instantiation has any dependent base classes, then the
   *qualified-id* is a member of an unknown specialization; see
   below. — *end note*]
 - An *id-expression* denoting the member in a class member access
+  expression [[expr.ref]] for which the type of the object expression is
+  the current instantiation, and the *id-expression*, when looked up
+  [[basic.lookup.classref]], refers to at least one member of a class
+  that is the current instantiation or a non-dependent base class
+  thereof. \[*Note 5*: If no such member is found, and the current
   instantiation has any dependent base classes, then the *id-expression*
   is a member of an unknown specialization; see below. — *end note*]
 [*Example 3*:
   current instantiation, the current instantiation has at least one
   dependent base class, and name lookup of the *qualified-id* does not
   find any member of a class that is the current instantiation or a
   non-dependent base class thereof.
 - An *id-expression* denoting the member in a class member access
+  expression [[expr.ref]] in which either
   - the type of the object expression is the current instantiation, the
     current instantiation has at least one dependent base class, and
     name lookup of the *id-expression* does not find a member of a class
     that is the current instantiation or a non-dependent base class
     thereof; or
+  - the type of the object expression is not the current instantiation
+ and the object expression is type-dependent.
 If a *qualified-id* in which the *nested-name-specifier* refers to the
 current instantiation is not a member of the current instantiation or a
 member of an unknown specialization, the program is ill-formed even if
 the template containing the *qualified-id* is not instantiated; no
 - a cv-qualified type where the cv-unqualified type is dependent,
 - a compound type constructed from any dependent type,
 - an array type whose element type is dependent or whose bound (if any)
   is value-dependent,
 - a function type whose exception specification is value-dependent,
+- denoted by a *simple-template-id* in which either the template name is
+ a template parameter or any of the template arguments is a dependent
+ type or an expression that is type-dependent or value-dependent or is
+ a pack expansion \[*Note 6*: This includes an injected-class-name
+  [[class.pre]] of a class template used without a
   *template-argument-list*. — *end note*] , or
 - denoted by `decltype(`*expression*`)`, where *expression* is
+  type-dependent [[temp.dep.expr]].
+[*Note 7*: Because typedefs do not introduce new types, but instead
 simply refer to other types, a name that refers to a typedef that is a
 member of the current instantiation is dependent only if the type
 referred to is dependent. — *end note*]
 #### Type-dependent expressions <a id="temp.dep.expr">[[temp.dep.expr]]</a>
 subexpression is type-dependent.
 `this`
 is type-dependent if the class type of the enclosing member function is
+dependent [[temp.dep.type]].
+An *id-expression* is type-dependent if it is not a concept-id and it
+contains
 - an *identifier* associated by name lookup with one or more
   declarations declared with a dependent type,
 - an *identifier* associated by name lookup with a non-type
   *template-parameter* declared with a type that contains a placeholder
+  type [[dcl.spec.auto]],
+- an *identifier* associated by name lookup with a variable declared
+  with a type that contains a placeholder type [[dcl.spec.auto]] where
+  the initializer is type-dependent,
 - an *identifier* associated by name lookup with one or more
   declarations of member functions of the current instantiation declared
   with a return type that contains a placeholder type,
 - an *identifier* associated by name lookup with a structured binding
+  declaration [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
+  type-dependent,
+- the *identifier* `__func__` [[dcl.fct.def.general]], where any
   enclosing function is a template, a member of a class template, or a
   generic lambda,
 - a *template-id* that is dependent,
 - a *conversion-function-id* that specifies a dependent type, or
 - a *nested-name-specifier* or a *qualified-id* that names a member of
   an unknown specialization;
 or if it names a dependent member of the current instantiation that is a
+static data member of type “array of unknown bound of `T`” for some `T`
+[[temp.static]]. Expressions of the following forms are type-dependent
+only if the type specified by the *type-id*, *simple-type-specifier* or
+*new-type-id* is dependent, even if any subexpression is type-dependent:
+``` bnf
+simple-type-specifier '(' expression-listₒₚₜ ')'
+'::'ₒₚₜ new new-placementₒₚₜ new-type-id new-initializerₒₚₜ
+'::'ₒₚₜ new new-placementₒₚₜ '(' type-id ')' new-initializerₒₚₜ
+dynamic_cast '<' type-id '>' '(' expression ')'
+static_cast '<' type-id '>' '(' expression ')'
+const_cast '<' type-id '>' '(' expression ')'
+reinterpret_cast '<' type-id '>' '(' expression ')'
+'(' type-id ')' cast-expression
+```
 Expressions of the following forms are never type-dependent (because the
 type of the expression cannot be dependent):
+``` bnf
+literal
+sizeof unary-expression
+sizeof '(' type-id ')'
+sizeof '...' '(' identifier ')'
+alignof '(' type-id ')'
+typeid '(' expression ')'
+typeid '(' type-id ')'
+'::'ₒₚₜ delete cast-expression
+'::'ₒₚₜ delete '[' ']' cast-expression
+throw assignment-expressionₒₚₜ
+noexcept '(' expression ')'
+```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
+A class member access expression [[expr.ref]] is type-dependent if the
+expression refers to a member of the current instantiation and the type
+of the referenced member is dependent, or the class member access
 expression refers to a member of an unknown specialization.
 [*Note 2*: In an expression of the form `x.y` or `xp->y` the type of
 the expression is usually the type of the member `y` of the class of `x`
 (or the class pointed to by `xp`). However, if `x` or `xp` refers to a
 constant expression is required is value-dependent if any subexpression
 is value-dependent.
 An *id-expression* is value-dependent if:
+- it is a concept-id and any of its arguments are dependent,
 - it is type-dependent,
 - it is the name of a non-type template parameter,
 - it names a static data member that is a dependent member of the
   current instantiation and is not initialized in a *member-declarator*,
 - it names a static member function that is a dependent member of the
   current instantiation, or
+- it names a potentially-constant variable [[expr.const]] that is
+ initialized with an expression that is value-dependent.
 Expressions of the following form are value-dependent if the
 *unary-expression* or *expression* is type-dependent or the *type-id* is
 dependent:
+``` bnf
+sizeof unary-expression
+sizeof '(' type-id ')'
+typeid '(' expression ')'
+typeid '(' type-id ')'
+alignof '(' type-id ')'
+noexcept '(' expression ')'
+```
 [*Note 1*: For the standard library macro `offsetof`, see
 [[support.types]]. — *end note*]
 Expressions of the following form are value-dependent if either the
 *type-id* or *simple-type-specifier* is dependent or the *expression* or
 *cast-expression* is value-dependent:
+``` bnf
+simple-type-specifier '(' expression-listₒₚₜ ')'
+static_cast '<' type-id '>' '(' expression ')'
+const_cast '<' type-id '>' '(' expression ')'
+reinterpret_cast '<' type-id '>' '(' expression ')'
+'(' type-id ')' cast-expression
+```
 Expressions of the following form are value-dependent:
+``` bnf
+sizeof '...' '(' identifier ')'
+fold-expression
+```
 An expression of the form `&`*qualified-id* where the *qualified-id*
 names a dependent member of the current instantiation is
 value-dependent. An expression of the form `&`*cast-expression* is also
 value-dependent if evaluating *cast-expression* as a core constant
+expression [[expr.const]] succeeds and the result of the evaluation
 refers to a templated entity that is an object with static or thread
 storage duration or a member function.
 #### Dependent template arguments <a id="temp.dep.temp">[[temp.dep.temp]]</a>
 — *end example*]
 ### 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*]
 ### Friend names declared within a class template <a id="temp.inject">[[temp.inject]]</a>
 Friend classes or functions can be declared within a class template.
 When a template is instantiated, the names of its friends are treated as
 if the specialization had been explicitly declared at its point of
 instantiation.
 As with non-template classes, the names of namespace-scope friend
 functions of a class template specialization are not visible during an
+ordinary lookup unless explicitly declared at namespace scope
+[[class.friend]]. Such names may be found under the rules for associated
+classes [[basic.lookup.argdep]].[^11]
 [*Example 1*:
 ``` cpp
 template<typename T> struct number {
 void g() {
   number<double> a(3), b(4);
   a = gcd(a,b);     // finds gcd because number<double> is an associated class,
                     // making gcd visible in its namespace (global scope)
+  b = gcd(3,4);     // error: gcd is not visible
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa