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

Files changed (1) hide show

tmp/tmp1huivh24/{from.md → to.md} +272 -489

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

@@ -1,60 +1,109 @@
 ## Name resolution <a id="temp.res">[[temp.res]]</a>
-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
-the keyword `typename`.
 [*Example 1*:
 ``` cpp
-// no B declared here
-class X;
-template<class T> class Y {
-  class Z; // forward declaration of member class
-  void f() {
-    X* a1;                      // declare pointer to X
-    T* a2;                      // declare pointer to T
-    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 {
   struct X { };
   int X;
@@ -66,52 +115,44 @@ template<class T> void f(T t) {
   typename T::X x;
 }
 void foo() {
   A a;
   B b;
-  f(b);             // OK: T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
 — *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
@@ -129,15 +170,16 @@ template<typename T> void f() {
 }
 ```
 — *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
 }
@@ -156,63 +198,53 @@ 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 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
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
   corresponding construct in any actual instantiation of the template.
-  \[*Note 3*:
 This can happen in situations including the following:
 - a type used in a non-dependent name is incomplete at the point at
   which a template is defined but is complete at the point at which an
   instantiation is performed, or
 - lookup for a name in the template definition found a
- *using-declaration*, but the lookup in the corresponding scope in
-    the instantiation does not find any declarations because the
- *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,
   and that entity was not defined when the template was defined, or
@@ -226,23 +258,25 @@ The program is ill-formed, no diagnostic required, if:
 — *end note*]
 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) {
     t = i;          // diagnosed if X::f is instantiated, and the assignment to t is an error
     p = i;          // may be diagnosed even if X::f is not instantiated
     p = j;          // may be diagnosed even if X::f is not instantiated
   }
   void g(T t) {
     +;              // may be diagnosed even if X::g is not instantiated
   }
 };
@@ -254,79 +288,11 @@ template<class... T> union X : T... { };            // error: union with base cl
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
 — *end example*]
-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;
-template<class T> class Set {
-  T* p;
-  int cnt;
-public:
-  Set();
-  Set<T>(const Set<T>&);
-  void printall() {
-    for (int i = 0; i<cnt; i++)
-      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) {
-  f(1);             // f(char)
-  f(T(1));          // dependent
-  f(t);             // dependent
-  dd++;             // not dependent; error: declaration for dd not found
-}
-enum E { e };
-void f(E);
-double dd;
-void h() {
-  g(e);             // will cause one call of f(char) followed by two calls of f(E)
-  g('a');           // will cause three calls of f(char)
-}
-```
-— *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>
@@ -337,18 +303,18 @@ 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
-specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
@@ -365,11 +331,11 @@ template<> class Y<int> {
 — *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 Base {
@@ -378,12 +344,12 @@ 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<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
@@ -421,135 +387,105 @@ template<class T> class X {
 };
 ```
 — *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 {
-  int T;                                // error: template-parameter redeclared
   void f() {
-    char T;                             // error: template-parameter redeclared
   }
 };
-template<class X> class X;              // error: template-parameter redeclared
 ```
 — *end example*]
-In the definition of a member of a class template that appears outside
-of the class template definition, the name of a member of the class
-template hides the name of a *template-parameter* of any enclosing class
-templates (but not a *template-parameter* of the member if the member is
-a class or function template).
 [*Example 6*:
 ``` cpp
-template<class T> struct A {
-  struct B { ... };
     typedef void C;
     void f();
     template<class U> void g(U);
   };
-template<class B> void A<B>::f() {
-  B b;              // A's B, not the template parameter
 }
-template<class B> template<class C> void A<B>::g(C) {
- B b; // A's B, not the template parameter
-  C c;              // the template parameter C, not A's C
 }
-```
-— *end example*]
-In the definition of a member of a class template that appears outside
-of the namespace containing the class template definition, the name of a
-*template-parameter* hides the name of a member of this namespace.
-[*Example 7*:
-``` cpp
-namespace N {
-  class C { };
-  template<class T> class B {
-    void f(T);
-  };
-}
-template<class C> void N::B<C>::f(C) {
-  C b;              // C is the template parameter, not N::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 {
-  struct B { ... };
-  int a;
-  int Y;
-};
-template<class B, class a> struct X : A {
-  B b;              // A's B
-  a b;              // error: A's a isn't a type name
-};
-```
-— *end example*]
 ### Dependent names <a id="temp.dep">[[temp.dep]]</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
@@ -565,88 +501,30 @@ template<class T> struct X : B<T> {
 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*:
-``` cpp
-typedef double A;
-template<class T> class B {
-  typedef int A;
-};
-template<class T> struct X : B<T> {
-  A a;              // a has type double
-};
-```
-The type name `A` in the definition of `X<T>` binds to the typedef name
-defined in the global namespace scope, not to the typedef name defined
-in the base class `B<T>`.
-— *end example*]
-[*Example 3*:
-``` cpp
-struct A {
-  struct B { ... };
-  int a;
-  int Y;
-};
-int a;
-template<class T> struct Y : T {
-  struct B { ... };
-  B b;                          // The B defined in Y
-  void f(int i) { a = i; }      // ::a
-  Y* p;                         // Y<T>
-};
-Y<A> ya;
-```
-The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
-not affect the binding of names in `Y<A>`.
-— *end example*]
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</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 [[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
@@ -728,32 +606,17 @@ template<class T> struct A<T>::B::C : A<T> {
 — *end example*]
 — *end note*]
-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*:
 ``` cpp
 template <class T> class A {
@@ -769,66 +632,51 @@ template <class T> int A<T>::f() {
 }
 ```
 — *end example*]
-A name is a *dependent member of the current instantiation* if it is a
-member of the current instantiation that, when looked up, refers to at
-least one member of a class that is the current instantiation.
-A name is a *member of an unknown specialization* if it is
-- A *qualified-id* in which the *nested-name-specifier* names a
-  dependent type that is not the current instantiation.
-- A *qualified-id* in which the *nested-name-specifier* refers to the
- 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
-diagnostic required. Similarly, if the *id-expression* in a class member
-access expression for which the type of the object expression is the
-current instantiation does not refer to a member of the current
-instantiation or a member of an unknown specialization, the program is
-ill-formed even if the template containing the member access expression
-is not instantiated; no diagnostic required.
 [*Example 4*:
 ``` cpp
-template<class T> class A {
- typedef int type;
- void f() {
-    A<T>::type i;               // OK: refers to a member of the current instantiation
-    typename A<T>::other j;     // error: neither a member of the current instantiation nor
-                                // a member of an unknown specialization
-  }
 };
 ```
 — *end example*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
-instantiation with a *qualified-id* or class member access expression,
-the name in the *qualified-id* or class member access expression is
-looked up in the template instantiation context. If the result of this
-lookup differs from the result of name lookup in the template definition
-context, name lookup is ambiguous.
 [*Example 5*:
 ``` cpp
 struct A {
@@ -844,84 +692,87 @@ struct C : A, T {
   int f() { return this->m; }   // finds A::m in the template definition context
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
-template int C<B>::g();         // OK: transformation to class member access syntax
-                                // does not occur in the template definition context; see~[class.mfct.non-static]
 ```
 — *end example*]
 A type is dependent if it is
 - a template parameter,
-- a member of an unknown specialization,
-- a nested class or enumeration that is a dependent member of the
-  current instantiation,
 - 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>
 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 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 ')'
@@ -948,21 +799,19 @@ 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
 dependent type that is not the current instantiation, the type of `y` is
-always dependent. If `x` or `xp` refers to a non-dependent type or
-refers to the current instantiation, the type of `y` is the type of the
-class member access expression. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
@@ -1039,38 +888,12 @@ the constant expression it specifies is value-dependent.
 Furthermore, a non-type *template-argument* is dependent if the
 corresponding non-type *template-parameter* is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
-A template *template-argument* is dependent if it names a
-*template-parameter* or is a *qualified-id* that refers to a member of
-an unknown specialization.
-### Non-dependent names <a id="temp.nondep">[[temp.nondep]]</a>
-Non-dependent names used in a template definition are found using the
-usual name lookup and bound at the point they are used.
-[*Example 1*:
-``` cpp
-void g(double);
-void h();
-template<class T> class Z {
-public:
-  void f() {
-    g(1);           // calls g(double)
-    h++;            // ill-formed: cannot increment function; this could be diagnosed
-                    // either here or at the point of instantiation
-  }
-};
-void g(int);        // not in scope at the point of the template definition, not considered for the call g(1)
-```
-— *end example*]
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
@@ -1142,26 +965,17 @@ 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"\`
@@ -1261,11 +1075,11 @@ Module interface unit of \`M\`
 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*]
@@ -1357,36 +1171,5 @@ void k() {
 }
 ```
 — *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 {
-  number(int);
-  friend number gcd(number x, number y) { return 0; };
-};
-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*]

 ## Name resolution <a id="temp.res">[[temp.res]]</a>
+### General <a id="temp.res.general">[[temp.res.general]]</a>
+A name that appears in a declaration D of a template T is looked up from
+where it appears in an unspecified declaration of T that either is D
+itself or is reachable from D and from which no other declaration of T
+that contains the usage of the name is reachable. If the name is
+dependent (as specified in [[temp.dep]]), it is looked up for each
+specialization (after substitution) because the lookup depends on a
+template parameter.
+[*Note 1*: Some dependent names are also looked up during parsing to
+determine that they are dependent or to interpret following `<` tokens.
+Uses of other names might be type-dependent or value-dependent
+[[temp.dep.expr]], [[temp.dep.constexpr]]. A *using-declarator* is never
+dependent in a specialization and is therefore replaced during lookup
+for that specialization [[basic.lookup]]. — *end note*]
 [*Example 1*:
 ``` cpp
+struct A { operator int(); };
+template<class B, class T>
+struct D : B {
+  T get() { return operator T(); }      // conversion-function-id is dependent
+};
+int f(D<A, int> d) { return d.get(); }  // OK, lookup finds A::operator int
+```
+— *end example*]
+[*Example 2*:
+``` cpp
+void f(char);
+template<class T> void g(T t) {
+  f(1);             // f(char)
+  f(T(1)); // dependent
+  f(t);             // dependent
+  dd++;             // not dependent; error: declaration for dd not found
 }
+enum E { e };
+void f(E);
+double dd;
+void h() {
+  g(e);             // will cause one call of f(char) followed by two calls of f(E)
+  g('a');           // will cause three calls of f(char)
+}
+```
+— *end example*]
+[*Example 3*:
+``` cpp
+struct A {
+  struct B { ... };
+  int a;
+  int Y;
+};
+int a;
+template<class T> struct Y : T {
+  struct B { ... };
+  B b;                          // The B defined in Y
+  void f(int i) { a = i; }      // ::a
+  Y* p;                         // Y<T>
 };
+Y<A> ya;
 ```
+The members `A::B`, `A::a`, and `A::Y` of the template argument `A` do
+not affect the binding of names in `Y<A>`.
 — *end example*]
+If the validity or meaning of the program would be changed by
+considering a default argument or default template argument introduced
+in a declaration that is reachable from the point of instantiation of a
+specialization [[temp.point]] but is not found by lookup for the
+specialization, the program is ill-formed, no diagnostic required.
 ``` bnf
 typename-specifier:
   typename nested-name-specifier identifier
   typename nested-name-specifier 'templateₒₚₜ ' simple-template-id
 ```
+The component names of a *typename-specifier* are its *identifier* (if
+any) and those of its *nested-name-specifier* and *simple-template-id*
+(if any). A *typename-specifier* denotes the type or class template
+denoted by the *simple-type-specifier* [[dcl.type.simple]] formed by
+omitting the keyword `typename`.
+[*Note 2*: The usual qualified name lookup [[basic.lookup.qual]]
+applies even in the presence of `typename`. — *end note*]
+[*Example 4*:
 ``` cpp
 struct A {
   struct X { };
   int X;
   typename T::X x;
 }
 void foo() {
   A a;
   B b;
+  f(b);             // OK, T::X refers to B::X
   f(a);             // error: T::X refers to the data member A::X not the struct A::X
 }
 ```
 — *end example*]
+A qualified or unqualified name is said to be in a *type-only context*
+if it is the terminal name of
+- a *typename-specifier*, *nested-name-specifier*,
+ *elaborated-type-specifier*, *class-or-decltype*, or
+- a *type-specifier* of a
+  - *new-type-id*,
+  - *defining-type-id*,
+ - *conversion-type-id*,
+ - *trailing-return-type*,
+  - default argument of a *type-parameter*, or
+  - *type-id* of a `static_cast`, `const_cast`, `reinterpret_cast`, or
+    `dynamic_cast`, or
+- 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*.
+[*Example 5*:
 ``` 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
 }
 ```
 — *end example*]
+A *qualified-id* whose terminal name is dependent and that is in a
+type-only context is considered to denote a type. A name that refers to
+a *using-declarator* whose terminal name is dependent is interpreted as
+a *typedef-name* if the *using-declarator* uses the keyword `typename`.
+[*Example 6*:
 ``` cpp
 template <class T> void f(int i) {
   T::x * i;         // expression, not the declaration of a variable i
 }
 }
 ```
 — *end example*]
 The validity of a template may be checked prior to any instantiation.
+[*Note 3*: 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, ignoring *static_assert-declaration*s that
+ fail, 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
+- any *constraint-expression* in the program, introduced or otherwise,
+  has (in its normal form) an atomic constraint A where no satisfaction
+  check of A could be well-formed and no satisfaction check of A is
+  performed, 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
 - the interpretation of such a construct in the hypothetical
   instantiation is different from the interpretation of the
   corresponding construct in any actual instantiation of the template.
+[*Note 4*:
 This can happen in situations including the following:
 - a type used in a non-dependent name is incomplete at the point at
   which a template is defined but is complete at the point at which an
   instantiation is performed, or
 - lookup for a name in the template definition found a
+ *using-declaration*, but the lookup in the corresponding scope in the
+ instantiation does not find any declarations because the
+ *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,
   and that entity was not defined when the template was defined, or
 — *end note*]
 Otherwise, no diagnostic shall be issued for a template for which a
 valid specialization can be generated.
+[*Note 5*: 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 7*:
 ``` cpp
 int j;
 template<class T> class X {
   void f(T t, int i, char* p) {
     t = i;          // diagnosed if X::f is instantiated, and the assignment to t is an error
     p = i;          // may be diagnosed even if X::f is not instantiated
     p = j;          // may be diagnosed even if X::f is not instantiated
+    X<T>::g(t);     // OK
+    X<T>::h();      // may be diagnosed even if X::f is not instantiated
   }
   void g(T t) {
     +;              // may be diagnosed even if X::g is not instantiated
   }
 };
 template<class... T> struct A : T...,  T... { };    // error: duplicate base class
 ```
 — *end example*]
+[*Note 6*: 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>
 *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 argument list
+[[temp.decls.general]], [[temp.arg.general]] of the class template
+enclosed in `<>`.
+When the injected-class-name of a class template specialization or
+partial specialization 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 specialization enclosed in `<>`.
 [*Example 1*:
 ``` cpp
 template<template<class> class T> class A { };
 — *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 named.
 [*Example 2*:
 ``` cpp
 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::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
 };
 ```
 — *end example*]
+The name of a *template-parameter* shall not be bound to any following
+declaration whose locus is contained by the scope to which the
+template-parameter belongs.
 [*Example 5*:
 ``` cpp
 template<class T, int i> class Y {
+  int T;                                // error: template-parameter hidden
   void f() {
+    char T;                             // error: template-parameter hidden
   }
+  friend void T();                      // OK, no name bound
 };
+template<class X> class X;              // error: hidden by template-parameter
 ```
 — *end example*]
+Unqualified name lookup considers the template parameter scope of a
+*template-declaration* immediately after the outermost scope associated
+with the template declared (even if its parent scope does not contain
+the *template-parameter-list*).
+[*Note 1*: The scope of a class template, including its non-dependent
+base classes [[temp.dep.type]], [[class.member.lookup]], is searched
+before its template parameter scope. — *end note*]
 [*Example 6*:
 ``` cpp
+struct B { };
+namespace N {
+  typedef void V;
+  template<class T> struct A : B {
     typedef void C;
     void f();
     template<class U> void g(U);
   };
 }
+template<class V> void N::A<V>::f() {   // N::V not considered here
+ V v; // V is still the template parameter, not N::V
 }
+template<class B> template<class C> void N::A<B>::g(C) {
+  B b;                                  // B is the base class, not the template parameter
+  C c;                                  // C is the template parameter, not A's C
 }
 ```
 — *end example*]
 ### Dependent names <a id="temp.dep">[[temp.dep]]</a>
+#### General <a id="temp.dep.general">[[temp.dep.general]]</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 below.
+A *dependent call* is an expression, possibly formed as a non-member
+candidate for an operator [[over.match.oper]], of the form:
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
+where the *postfix-expression* is an *unqualified-id* and
 - any of the expressions in the *expression-list* is a pack expansion
+  [[temp.variadic]], or
 - 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.
+The component name of an *unqualified-id* [[expr.prim.id.unqual]] is
+dependent if
+- it is a *conversion-function-id* whose *conversion-type-id* is
+  dependent, or
+- it is `operator=` and the current class is a templated entity, or
+- the *unqualified-id* is the *postfix-expression* in a dependent call.
+[*Note 1*: Such names are looked up only 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
 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*]
 #### Dependent types <a id="temp.dep.type">[[temp.dep.type]]</a>
+A name or *template-id* 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 its *template-head* [[temp.arg]] 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 class template partial specialization or a
+ member of a class template partial specialization, the name of the
+ class template followed by a template argument list equivalent to that
+ of the partial specialization [[temp.spec.partial]] enclosed in `<>`
+ (or an equivalent template alias specialization).
 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
 — *end example*]
 — *end note*]
+A qualified [[basic.lookup.qual]] or unqualified name is a *member of
+the current instantiation* if
+- its lookup context, if it is a qualified name, is the current
+  instantiation, and
+- lookup for it finds any member of a class that is the current
+ instantiation
 [*Example 3*:
 ``` cpp
 template <class T> class A {
 }
 ```
 — *end example*]
+A qualified or unqualified name names a *dependent member of the current
+instantiation* if it is a member of the current instantiation that, when
+looked up, refers to at least one member declaration (including a
+*using-declarator* whose terminal name is dependent) of a class that is
+the current instantiation.
+A qualified name [[basic.lookup.qual]] is dependent if
+- it is a *conversion-function-id* whose *conversion-type-id* is
+  dependent, or
+- its lookup context is dependent and is not the current instantiation,
+ or
+- its lookup context is the current instantiation and it is
+ `operator=`,[^11] or
+- its lookup context is the current instantiation and has at least one
+  dependent base class, and qualified name lookup for the name finds
+ nothing [[basic.lookup.qual]].
 [*Example 4*:
 ``` cpp
+struct A {
+ using B = int;
+ A f();
 };
+struct C : A {};
+template<class T>
+void g(T t) {
+  decltype(t.A::f())::B i;      // error: typename needed to interpret B as a type
+}
+template void g(C);             // … even though A is ::A here
 ```
 — *end example*]
 If, for a given set of template arguments, a specialization of a
 template is instantiated that refers to a member of the current
+instantiation with a qualified name, the name is looked up in the
+template instantiation context. If the result of this lookup differs
+from the result of name lookup in the template definition context, name
+lookup is ambiguous.
 [*Example 5*:
 ``` cpp
 struct A {
   int f() { return this->m; }   // finds A::m in the template definition context
   int g() { return m; }         // finds A::m in the template definition context
 };
 template int C<B>::f();         // error: finds both A::m and B::m
+template int C<B>::g();         // OK, transformation to class member access syntax
+                                // does not occur in the template definition context; see~[class.mfct.non.static]
 ```
 — *end example*]
 A type is dependent if it is
 - a template parameter,
+- denoted by a dependent (qualified) name,
+- a nested class or enumeration that is a direct member of a class that
+ is the current instantiation,
 - 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 parameters include one or more function
+  parameter packs,
 - 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,[^12] or
 - denoted by `decltype(`*expression*`)`, where *expression* is
   type-dependent [[temp.dep.expr]].
+[*Note 3*: 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>
 Except as described below, an expression is type-dependent if any
 subexpression is type-dependent.
+`this` is type-dependent if the current class [[expr.prim.this]] is
 dependent [[temp.dep.type]].
+An *id-expression* is type-dependent if it is a *template-id* that is
+not a concept-id and is dependent; or if its terminal name is
+- associated by name lookup with one or more declarations declared with
+  a dependent type,
+- associated by name lookup with a non-type *template-parameter*
+  declared with a type that contains a placeholder type
+  [[dcl.spec.auto]],
+- 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,
+- associated by name lookup with one or more declarations of member
+  functions of a class that is the current instantiation declared with a
+  return type that contains a placeholder type,
+- associated by name lookup with a structured binding declaration
+  [[dcl.struct.bind]] whose *brace-or-equal-initializer* is
+  type-dependent,
+- associated by name lookup with an entity captured by copy
+  [[expr.prim.lambda.capture]] in a *lambda-expression* that has an
+  explicit object parameter whose type is dependent [[dcl.fct]],
 - 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 *conversion-function-id* that specifies a dependent type, or
+- dependent
 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*,
+*typename-specifier*, or *new-type-id* is dependent, even if any
+subexpression is type-dependent:
 ``` bnf
 simple-type-specifier '(' expression-listₒₚₜ ')'
+simple-type-specifier braced-init-list
+typename-specifier '(' expression-listₒₚₜ ')'
+typename-specifier braced-init-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 ')'
 [*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
+terminal name of its *id-expression*, if any, is dependent or the
 expression refers to a member of the current instantiation and the type
+of the referenced member is dependent.
 [*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
 dependent type that is not the current instantiation, the type of `y` is
+always dependent. — *end note*]
 A *braced-init-list* is type-dependent if any element is type-dependent
 or is a pack expansion.
 A *fold-expression* is type-dependent.
 Furthermore, a non-type *template-argument* is dependent if the
 corresponding non-type *template-parameter* is of reference or pointer
 type and the *template-argument* designates or points to a member of the
 current instantiation or a member of a dependent type.
+A template *template-parameter* is dependent if it names a
+*template-parameter* or its terminal name is dependent.
 ### Dependent name resolution <a id="temp.dep.res">[[temp.dep.res]]</a>
 #### Point of instantiation <a id="temp.point">[[temp.point]]</a>
 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>
+If a dependent call [[temp.dep]] would be ill-formed or would find a
+better match had the lookup for its dependent name considered all the
+function declarations with external linkage introduced in the associated
+namespaces in all translation units, not just considering those
+declarations found in the template definition and template instantiation
+contexts [[basic.lookup.argdep]], then the program is ill-formed, no
+diagnostic required.
 [*Example 1*:
 Source file \`"X.h"\`
 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*]
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa