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

Files changed (1) hide show

tmp/tmpa61sm3n1/{from.md → to.md} +359 -163

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

@@ -1,9 +1,9 @@
 ## Template instantiation and specialization <a id="temp.spec">[[temp.spec]]</a>
-The act of instantiating a function, a class, a member of a class
-template or a member template is referred to as *template
 instantiation*.
 A function instantiated from a function template is called an
 instantiated function. A class instantiated from a class template is
 called an instantiated class. A member function, a member class, a
@@ -11,18 +11,22 @@ member enumeration, or a static data member of a class template
 instantiated from the member definition of the class template is called,
 respectively, an instantiated member function, member class, member
 enumeration, or static data member. A member function instantiated from
 a member function template is called an instantiated member function. A
 member class instantiated from a member class template is called an
-instantiated member class.
 An explicit specialization may be declared for a function template, a
-class template, a member of a class template or a member template. An
-explicit specialization declaration is introduced by `template<>`. In an
-explicit specialization declaration for a class template, a member of a
-class template or a class member template, the name of the class that is
-explicitly specialized shall be a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
 template, the name of the function or member function explicitly
 specialized may be a *template-id*.
 [*Example 1*:
@@ -47,27 +51,39 @@ template<> int B<>::x = 1;              // specialize for T == int
 ```
 — *end example*]
 An instantiated template specialization can be either implicitly
-instantiated ([[temp.inst]]) for a given argument list or be explicitly
-instantiated ([[temp.explicit]]). A specialization is a class,
-function, or class member that is either instantiated or explicitly
-specialized ([[temp.expl.spec]]).
 For a given template and a given set of *template-argument*s,
 - an explicit instantiation definition shall appear at most once in a
   program,
-- an explicit specialization shall be defined at most once in a program
- (according to  [[basic.def.odr]]), and
 - both an explicit instantiation and a declaration of an explicit
   specialization shall not appear in a program unless the explicit
   instantiation follows a declaration of the explicit specialization.
 An implementation is not required to diagnose a violation of this rule.
 Each class template specialization instantiated from a template has its
 own copy of any static members.
 [*Example 2*:
@@ -86,35 +102,50 @@ has a static member `s` of type `int` and `X<char*>` has a static member
 `s` of type `char*`.
 — *end example*]
 If a function declaration acquired its function type through a dependent
-type ([[temp.dep.type]]) without using the syntactic form of a function
 declarator, the program is ill-formed.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
   static T t;
 };
 typedef int function();
-A<function> a;      // ill-formed: would declare A<function>::t as a static member function
 ```
 — *end example*]
 ### Implicit instantiation <a id="temp.inst">[[temp.inst]]</a>
-Unless a class template specialization has been explicitly
-instantiated ([[temp.explicit]]) or explicitly specialized (
-[[temp.expl.spec]]), the class template specialization is implicitly
-instantiated when the specialization is referenced in a context that
-requires a completely-defined object type or when the completeness of
-the class type affects the semantics of the program.
-[*Note 1*: In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
 class template specialization is implicitly generated. For instance,
 deleting a pointer to class type depends on whether or not the class
 declares a destructor, and a conversion between pointers to class type
 depends on the inheritance relationship between the two classes
@@ -137,44 +168,65 @@ void g(D<int>* p, D<char>* pp, D<double>* ppp) {
 ```
 — *end example*]
 If a class template has been declared, but not defined, at the point of
-instantiation ([[temp.point]]), the instantiation yields an incomplete
-class type ([[basic.types]]).
 [*Example 2*:
 ``` cpp
 template<class T> class X;
 X<char> ch;         // error: incomplete type X<char>
 ```
 — *end example*]
-[*Note 2*: Within a template declaration, a local class (
-[[class.local]]) or enumeration and the members of a local class are
-never considered to be entities that can be separately instantiated
-(this includes their default arguments, *noexcept-specifier*s, and
-non-static data member initializers, if any). As a result, the dependent
-names are looked up, the semantic constraints are checked, and any
-templates used are instantiated as part of the instantiation of the
-entity within which the local class or enumeration is
-declared. — *end note*]
-The implicit instantiation of a class template specialization causes the
-implicit instantiation of the declarations, but not of the definitions,
-default arguments, or *noexcept-specifier*s of the class member
-functions, member classes, scoped member enumerations, static data
-members, member templates, and friends; and it causes the implicit
-instantiation of the definitions of unscoped member enumerations and
-member anonymous unions. However, for the purpose of determining whether
-an instantiated redeclaration is valid according to  [[basic.def.odr]]
-and [[class.mem]], a declaration that corresponds to a definition in the
 template is considered to be a definition.
-[*Example 3*:
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
@@ -195,38 +247,47 @@ same partial specialization.
 ``` cpp
 template<typename T> struct Friendly {
   template<typename U> friend int f(U) { return sizeof(T); }
 };
 Friendly<char> fc;
-Friendly<float> ff;                             // ill-formed: produces second definition of f(U)
 ```
 — *end example*]
-Unless a member of a class template or a member template has been
-explicitly instantiated or explicitly specialized, the specialization of
-the member is implicitly instantiated when the specialization is
-referenced in a context that requires the member definition to exist; in
 particular, the initialization (and any associated side effects) of a
 static data member does not occur unless the static data member is
 itself used in a way that requires the definition of the static data
 member to exist.
-Unless a function template specialization has been explicitly
-instantiated or explicitly specialized, the function template
-specialization is implicitly instantiated when the specialization is
-referenced in a context that requires a function definition to exist. A
-function whose declaration was instantiated from a friend function
-definition is implicitly instantiated when it is referenced in a context
-that requires a function definition to exist. Unless a call is to a
-function template explicit specialization or to a member function of an
-explicitly specialized class template, a default argument for a function
-template or a member function of a class template is implicitly
-instantiated when the function is called in a context that requires the
-value of the default argument.
-[*Example 4*:
 ``` cpp
 template<class T> struct Z {
   void f();
   void g();
@@ -246,22 +307,46 @@ void h() {
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
 — *end example*]
-Unless a variable template specialization has been explicitly
-instantiated or explicitly specialized, the variable template
-specialization is implicitly instantiated when the specialization is
-used. A default template argument for a variable template is implicitly
-instantiated when the variable template is referenced in a context that
-requires the value of the default argument.
-If the function selected by overload resolution ([[over.match]]) can be
 determined without instantiating a class template definition, it is
 unspecified whether that instantiation actually takes place.
-[*Example 5*:
 ``` cpp
 template <class T> struct S {
   operator int();
 };
@@ -278,34 +363,41 @@ void g(S<int>& sr) {
 — *end example*]
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
-specialization is implicitly instantiated ([[temp.over]]).
 An implementation shall not implicitly instantiate a function template,
 a variable template, a member template, a non-virtual member function, a
 member class, a static data member of a class template, or a
-substatement of a constexpr if statement ([[stmt.if]]), unless such
-instantiation is required. It is unspecified whether or not an
-implementation implicitly instantiates a virtual member function of a
-class template if the virtual member function would not otherwise be
-instantiated. The use of a template specialization in a default argument
-shall not cause the template to be implicitly instantiated except that a
-class template may be instantiated where its complete type is needed to
-determine the correctness of the default argument. The use of a default
-argument in a function call causes specializations in the default
-argument to be implicitly instantiated.
 Implicitly instantiated class, function, and variable template
 specializations are placed in the namespace where the template is
 defined. Implicitly instantiated specializations for members of a class
 template are placed in the namespace where the enclosing class template
 is defined. Implicitly instantiated member templates are placed in the
 namespace where the enclosing class or class template is defined.
-[*Example 6*:
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
@@ -322,11 +414,11 @@ public:
 void g(Map<const char*,int>& m) {
   int i = m.get("Nicholas");
 }
 ```
-a call of `lt.get()` from `Map<const char*,int>::get()` would place
 `List<int>::get()` in the namespace `N` rather than in the global
 namespace.
 — *end example*]
@@ -335,19 +427,19 @@ argument to be used, the dependent names are looked up, the semantics
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
 function template `f` used at that point, except that the scope in which
-a closure type is declared ([[expr.prim.lambda.closure]]) – and
-therefore its associated namespaces – remain as determined from the
-context of the definition for the default argument. This analysis is
-called *default argument instantiation*. The instantiated default
-argument is then used as the argument of `f`.
 Each default argument is instantiated independently.
-[*Example 7*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
@@ -355,34 +447,34 @@ class  A { };
 A zdef(A);
 void g(A a, A b, A c) {
   f(a, b, c);       // no default argument instantiation
   f(a, b);          // default argument z = zdef(T()) instantiated
-  f(a);             // ill-formed; ydef is not declared
 }
 ```
 — *end example*]
 The *noexcept-specifier* of a function template specialization is not
 instantiated along with the function declaration; it is instantiated
-when needed ([[except.spec]]). If such an *noexcept-specifier* is
-needed but has not yet been instantiated, the dependent names are looked
-up, the semantics constraints are checked, and the instantiation of any
 template used in the *noexcept-specifier* is done as if it were being
 done as part of instantiating the declaration of the specialization at
 that point.
-[*Note 3*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
-on the total depth of recursive instantiations ([[implimits]]), which
 could involve more than one template. The result of an infinite
 recursion in instantiation is undefined.
-[*Example 8*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
@@ -391,53 +483,119 @@ template<class T> class X {
 };
 ```
 — *end example*]
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
 A class, function, variable, or member template specialization can be
 explicitly instantiated from its template. A member function, member
 class or static data member of a class template can be explicitly
 instantiated from the member definition associated with its class
-template. An explicit instantiation of a function template or member
-function of a class template shall not use the `inline` or `constexpr`
-specifiers.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
- 'extern'ₒₚₜ 'template' declaration
 ```
 There are two forms of explicit instantiation: an explicit instantiation
 definition and an explicit instantiation declaration. An explicit
 instantiation declaration begins with the `extern` keyword.
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
-*simple-template-id*. If the explicit instantiation is for a function or
-member function, the *unqualified-id* in the *declaration* shall be
-either a *template-id* or, where all template arguments can be deduced,
-a *template-name* or *operator-function-id*.
 [*Note 1*: The declaration may declare a *qualified-id*, in which case
 the *unqualified-id* of the *qualified-id* must be a
 *template-id*. — *end note*]
 If the explicit instantiation is for a member function, a member class
 or a static data member of a class template specialization, the name of
 the class template specialization in the *qualified-id* for the member
 name shall be a *simple-template-id*. If the explicit instantiation is
-for a variable, the *unqualified-id* in the declaration shall be a
-*template-id*. An explicit instantiation shall appear in an enclosing
-namespace of its template. If the name declared in the explicit
-instantiation is an unqualified name, the explicit instantiation shall
-appear in the namespace where its template is declared or, if that
-namespace is inline ([[namespace.def]]), any namespace from its
-enclosing namespace set.
 [*Note 2*: Regarding qualified names in declarators, see
 [[dcl.meaning]]. — *end note*]
 [*Example 1*:
@@ -465,17 +623,50 @@ instantiation of that entity. A definition of a class template, a member
 class of a class template, or a member class template of a class or
 class template shall precede an explicit instantiation of that entity
 unless the explicit instantiation is preceded by an explicit
 specialization of the entity with the same template arguments. If the
 *declaration* of the explicit instantiation names an implicitly-declared
-special member function (Clause  [[special]]), the program is
-ill-formed.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
-an explicit instantiation definition the definition of a function
 template, a variable template, a member function template, or a member
 function or static data member of a class template shall be present in
 every translation unit in which it is explicitly instantiated.
 An explicit instantiation of a class, function template, or variable
@@ -483,11 +674,11 @@ template specialization is placed in the namespace in which the template
 is defined. An explicit instantiation for a member of a class template
 is placed in the namespace where the enclosing class template is
 defined. An explicit instantiation for a member template is placed in
 the namespace where the enclosing class or class template is defined.
-[*Example 2*:
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
@@ -504,13 +695,13 @@ template void N::Y<double>::mf();       // OK: explicit instantiation in namespa
 — *end example*]
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
 function template specialization provided it can be deduced from the
-type of a function parameter ([[temp.deduct]]).
-[*Example 3*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
@@ -518,70 +709,63 @@ template<class T> void sort(Array<T>& v) { ... }
 template void sort<>(Array<int>&);
 ```
 — *end example*]
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
 base classes and members that are templates) that has not been
 previously explicitly specialized in the translation unit containing the
-explicit instantiation, except as described below.
-[*Note 3*: In addition, it will typically be an explicit instantiation
 of certain implementation-dependent data about the class. — *end note*]
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
-Except for inline functions and variables, declarations with types
-deduced from their initializer or return value ([[dcl.spec.auto]]),
-`const` variables of literal types, variables of reference types, and
-class template specializations, explicit instantiation declarations have
-the effect of suppressing the implicit instantiation of the entity to
-which they refer.
-[*Note 4*: The intent is that an inline function that is the subject of
-an explicit instantiation declaration will still be implicitly
-instantiated when odr-used ([[basic.def.odr]]) so that the body can be
-considered for inlining, but that no out-of-line copy of the inline
-function would be generated in the translation unit. — *end note*]
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
-also used in a way that would otherwise cause an implicit
-instantiation ([[temp.inst]]) in the translation unit shall be the
-subject of an explicit instantiation definition somewhere in the
-program; otherwise the program is ill-formed, no diagnostic required.
-[*Note 5*: This rule does apply to inline functions even though an
 explicit instantiation declaration of such an entity has no other
 normative effect. This is needed to ensure that if the address of an
 inline function is taken in a translation unit in which the
 implementation chose to suppress the out-of-line body, another
 translation unit will supply the body. — *end note*]
 An explicit instantiation declaration shall not name a specialization of
 a template with internal linkage.
-The usual access checking rules do not apply to names used to specify
-explicit instantiations.
-[*Note 6*: In particular, the template arguments and names used in the
-function declarator (including parameter types, return types and
-exception specifications) may be private types or objects which would
-normally not be accessible and the template may be a member template or
-member function which would not normally be accessible. — *end note*]
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
-[*Example 4*:
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
@@ -605,11 +789,11 @@ An explicit specialization of any of the following:
 can be declared by a declaration introduced by `template<>`; that is:
 ``` bnf
 explicit-specialization:
- 'template < >' declaration
 ```
 [*Example 1*:
 ``` cpp
@@ -630,10 +814,13 @@ specializations instantiated from the class template. Similarly,
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
 — *end example*]
 An explicit specialization may be declared in any scope in which the
 corresponding primary template may be defined ([[namespace.memdef]],
 [[class.mem]], [[temp.mem]]).
 A declaration of a function template, class template, or variable
@@ -664,12 +851,12 @@ enumeration, a member class template, a static data member, or a static
 data member template of a class template may be explicitly specialized
 for a class specialization that is implicitly instantiated; in this
 case, the definition of the class template shall precede the explicit
 specialization for the member of the class template. If such an explicit
 specialization for the member of a class template names an
-implicitly-declared special member function (Clause  [[special]]), the
-program is ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
@@ -763,11 +950,11 @@ template<class T> struct A {
 };
 template<> enum A<int>::E : int { eint };           // OK
 template<> enum class A<int>::S : int { sint };     // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
-template<> enum A<char>::E : char { echar };        // ill-formed, A<char>::E was instantiated
                                                     // when A<char> was instantiated
 template<> enum class A<char>::S : char { schar };  // OK
 ```
 — *end example*]
@@ -811,12 +998,12 @@ template<> class N::Y<short> { ... };     // OK: specialization in enclosing nam
 — *end example*]
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
-exactly like the names of other incompletely-defined classes (
-[[basic.types]]).
 [*Example 6*:
 ``` cpp
 template<class T> class X;                      // X is a class template
@@ -843,18 +1030,27 @@ template<class T> void sort(Array<T>& v);
 template<> void sort(Array<int>&);
 ```
 — *end example*]
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
-specialization ([[temp.fct]]).
-An explicit specialization of a function or variable template is inline
-only if it is declared with the `inline` specifier or defined as
-deleted, and independently of whether its function or variable template
-is inline.
 [*Example 8*:
 ``` cpp
 template<class T> void f(T) { ... }
@@ -869,11 +1065,11 @@ template<> int g<>(int) { ... }           // OK: not inline
 An explicit specialization of a static data member of a template or an
 explicit specialization of a static data member template is a definition
 if the declaration includes an initializer; otherwise, it is a
 declaration.
-[*Note 2*:
 The definition of a static data member of a template that requires
 default-initialization must use a *braced-init-list*:
 ``` cpp
@@ -943,11 +1139,11 @@ template<> template<> void A<char>::B<char>::mf();
 In an explicit specialization declaration for a member of a class
 template or a member template that appears in namespace scope, the
 member template and some of its enclosing class templates may remain
 unspecialized, except that the declaration shall not explicitly
 specialize a class member template if its enclosing class templates are
-not explicitly specialized as well. In such explicit specialization
 declaration, the keyword `template` followed by a
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
 types of the *template-parameter*s in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
@@ -966,11 +1162,11 @@ template <> template <class X>
       template <class T> void mf1(T);
   };
 template <> template <> template<class T>
   void A<int>::B<double>::mf1(T t) { }
 template <class Y> template <>
-  void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                         // its enclosing class template A is not
 ```
 — *end example*]
@@ -986,10 +1182,10 @@ definition for one of the following explicit specializations:
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
-  specialization belongs is implicitly instantiated. \[*Note 3*: Default
   function arguments may be specified in the declaration or definition
   of a member function of a class template specialization that is
   explicitly specialized. — *end note*]

 ## Template instantiation and specialization <a id="temp.spec">[[temp.spec]]</a>
+The act of instantiating a function, a variable, a class, a member of a
+class template, or a member template is referred to as *template
 instantiation*.
 A function instantiated from a function template is called an
 instantiated function. A class instantiated from a class template is
 called an instantiated class. A member function, a member class, a
 instantiated from the member definition of the class template is called,
 respectively, an instantiated member function, member class, member
 enumeration, or static data member. A member function instantiated from
 a member function template is called an instantiated member function. A
 member class instantiated from a member class template is called an
+instantiated member class. A variable instantiated from a variable
+template is called an instantiated variable. A static data member
+instantiated from a static data member template is called an
+instantiated static data member.
 An explicit specialization may be declared for a function template, a
+variable template, a class template, a member of a class template, or a
+member template. An explicit specialization declaration is introduced by
+`template<>`. In an explicit specialization declaration for a variable
+template, a class template, a member of a class template or a class
+member template, the name of the variable or class that is explicitly
+specialized shall be a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
 template, the name of the function or member function explicitly
 specialized may be a *template-id*.
 [*Example 1*:
 ```
 — *end example*]
 An instantiated template specialization can be either implicitly
+instantiated [[temp.inst]] for a given argument list or be explicitly
+instantiated [[temp.explicit]]. A *specialization* is a class, variable,
+function, or class member that is either instantiated [[temp.inst]] from
+a templated entity or is an explicit specialization [[temp.expl.spec]]
+of a templated entity.
 For a given template and a given set of *template-argument*s,
 - an explicit instantiation definition shall appear at most once in a
   program,
+- an explicit specialization shall be defined at most once in a program,
+ as specified in [[basic.def.odr]], and
 - both an explicit instantiation and a declaration of an explicit
   specialization shall not appear in a program unless the explicit
   instantiation follows a declaration of the explicit specialization.
 An implementation is not required to diagnose a violation of this rule.
+The usual access checking rules do not apply to names in a declaration
+of an explicit instantiation or explicit specialization, with the
+exception of names appearing in a function body, default argument,
+base-clause, member-specification, enumerator-list, or static data
+member or variable template initializer.
+[*Note 1*: In particular, the template arguments and names used in the
+function declarator (including parameter types, return types and
+exception specifications) may be private types or objects that would
+normally not be accessible. — *end note*]
 Each class template specialization instantiated from a template has its
 own copy of any static members.
 [*Example 2*:
 `s` of type `char*`.
 — *end example*]
 If a function declaration acquired its function type through a dependent
+type [[temp.dep.type]] without using the syntactic form of a function
 declarator, the program is ill-formed.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
   static T t;
 };
 typedef int function();
+A<function> a;      // error: would declare A<function>::t as a static member function
 ```
 — *end example*]
 ### Implicit instantiation <a id="temp.inst">[[temp.inst]]</a>
+A template specialization E is a *declared specialization* if there is a
+reachable explicit instantiation definition [[temp.explicit]] or
+explicit specialization declaration [[temp.expl.spec]] for E, or if
+there is a reachable explicit instantiation declaration for E and E is
+not
+- an inline function,
+- declared with a type deduced from its initializer or return value
+  [[dcl.spec.auto]],
+- a potentially-constant variable [[expr.const]], or
+- a specialization of a templated class.
+[*Note 1*: An implicit instantiation in an importing translation unit
+cannot use names with internal linkage from an imported translation unit
+[[basic.link]]. — *end note*]
+Unless a class template specialization is a declared specialization, the
+class template specialization is implicitly instantiated when the
+specialization is referenced in a context that requires a
+completely-defined object type or when the completeness of the class
+type affects the semantics of the program.
+[*Note 2*: In particular, if the semantics of an expression depend on
 the member or base class lists of a class template specialization, the
 class template specialization is implicitly generated. For instance,
 deleting a pointer to class type depends on whether or not the class
 declares a destructor, and a conversion between pointers to class type
 depends on the inheritance relationship between the two classes
 ```
 — *end example*]
 If a class template has been declared, but not defined, at the point of
+instantiation [[temp.point]], the instantiation yields an incomplete
+class type [[basic.types]].
 [*Example 2*:
 ``` cpp
 template<class T> class X;
 X<char> ch;         // error: incomplete type X<char>
 ```
 — *end example*]
+[*Note 3*: Within a template declaration, a local class [[class.local]]
+or enumeration and the members of a local class are never considered to
+be entities that can be separately instantiated (this includes their
+default arguments, *noexcept-specifier*s, and non-static data member
+initializers, if any, but not their *type-constraint*s or
+*requires-clause*s). As a result, the dependent names are looked up, the
+semantic constraints are checked, and any templates used are
+instantiated as part of the instantiation of the entity within which the
+local class or enumeration is declared. — *end note*]
+The implicit instantiation of a class template specialization causes
+- the implicit instantiation of the declarations, but not of the
+  definitions, of the non-deleted class member functions, member
+  classes, scoped member enumerations, static data members, member
+  templates, and friends; and
+- the implicit instantiation of the definitions of deleted member
+  functions, unscoped member enumerations, and member anonymous unions.
+The implicit instantiation of a class template specialization does not
+cause the implicit instantiation of default arguments or
+*noexcept-specifier*s of the class member functions.
+[*Example 3*:
+``` cpp
+template<class T>
+struct C {
+  void f() { T x; }
+  void g() = delete;
+};
+C<void> c;                      // OK, definition of C<void>::f is not instantiated at this point
+template<> void C<int>::g() { } // error: redefinition of C<int>::g
+```
+— *end example*]
+However, for the purpose of determining whether an instantiated
+redeclaration is valid according to  [[basic.def.odr]] and
+[[class.mem]], a declaration that corresponds to a definition in the
 template is considered to be a definition.
+[*Example 4*:
 ``` cpp
 template<class T, class U>
 struct Outer {
   template<class X, class Y> struct Inner;
 ``` cpp
 template<typename T> struct Friendly {
   template<typename U> friend int f(U) { return sizeof(T); }
 };
 Friendly<char> fc;
+Friendly<float> ff;                             // error: produces second definition of f(U)
 ```
 — *end example*]
+Unless a member of a class template or a member template is a declared
+specialization, the specialization of the member is implicitly
+instantiated when the specialization is referenced in a context that
+requires the member definition to exist or if the existence of the
+definition of the member affects the semantics of the program; in
 particular, the initialization (and any associated side effects) of a
 static data member does not occur unless the static data member is
 itself used in a way that requires the definition of the static data
 member to exist.
+Unless a function template specialization is a declared specialization,
+the function template specialization is implicitly instantiated when the
+specialization is referenced in a context that requires a function
+definition to exist or if the existence of the definition affects the
+semantics of the program. A function whose declaration was instantiated
+from a friend function definition is implicitly instantiated when it is
+referenced in a context that requires a function definition to exist or
+if the existence of the definition affects the semantics of the program.
+Unless a call is to a function template explicit specialization or to a
+member function of an explicitly specialized class template, a default
+argument for a function template or a member function of a class
+template is implicitly instantiated when the function is called in a
+context that requires the value of the default argument.
+[*Note 4*: An inline function that is the subject of an explicit
+instantiation declaration is not a declared specialization; the intent
+is that it still be implicitly instantiated when odr-used
+[[basic.def.odr]] so that the body can be considered for inlining, but
+that no out-of-line copy of it be generated in the translation
+unit. — *end note*]
+[*Example 5*:
 ``` cpp
 template<class T> struct Z {
   void f();
   void g();
 Nothing in this example requires `class` `Z<double>`, `Z<int>::g()`, or
 `Z<char>::f()` to be implicitly instantiated.
 — *end example*]
+Unless a variable template specialization is a declared specialization,
+the variable template specialization is implicitly instantiated when it
+is referenced in a context that requires a variable definition to exist
+or if the existence of the definition affects the semantics of the
+program. A default template argument for a variable template is
+implicitly instantiated when the variable template is referenced in a
+context that requires the value of the default argument.
+The existence of a definition of a variable or function is considered to
+affect the semantics of the program if the variable or function is
+needed for constant evaluation by an expression [[expr.const]], even if
+constant evaluation of the expression is not required or if constant
+expression evaluation does not use the definition.
+[*Example 6*:
+``` cpp
+template<typename T> constexpr int f() { return T::value; }
+template<bool B, typename T> void g(decltype(B ? f<T>() : 0));
+template<bool B, typename T> void g(...);
+template<bool B, typename T> void h(decltype(int{B ? f<T>() : 0}));
+template<bool B, typename T> void h(...);
+void x() {
+  g<false, int>(0); // OK, B ? f<T>() :\ 0 is not potentially constant evaluated
+  h<false, int>(0); // error, instantiates f<int> even though B evaluates to false and
+                    // list-initialization of int from int cannot be narrowing
+}
+```
+— *end example*]
+If the function selected by overload resolution [[over.match]] can be
 determined without instantiating a class template definition, it is
 unspecified whether that instantiation actually takes place.
+[*Example 7*:
 ``` cpp
 template <class T> struct S {
   operator int();
 };
 — *end example*]
 If a function template or a member function template specialization is
 used in a way that involves overload resolution, a declaration of the
+specialization is implicitly instantiated [[temp.over]].
 An implementation shall not implicitly instantiate a function template,
 a variable template, a member template, a non-virtual member function, a
 member class, a static data member of a class template, or a
+substatement of a constexpr if statement [[stmt.if]], unless such
+instantiation is required.
+[*Note 5*: The instantiation of a generic lambda does not require
+instantiation of substatements of a constexpr if statement within its
+*compound-statement* unless the call operator template is
+instantiated. — *end note*]
+It is unspecified whether or not an implementation implicitly
+instantiates a virtual member function of a class template if the
+virtual member function would not otherwise be instantiated. The use of
+a template specialization in a default argument shall not cause the
+template to be implicitly instantiated except that a class template may
+be instantiated where its complete type is needed to determine the
+correctness of the default argument. The use of a default argument in a
+function call causes specializations in the default argument to be
+implicitly instantiated.
 Implicitly instantiated class, function, and variable template
 specializations are placed in the namespace where the template is
 defined. Implicitly instantiated specializations for members of a class
 template are placed in the namespace where the enclosing class template
 is defined. Implicitly instantiated member templates are placed in the
 namespace where the enclosing class or class template is defined.
+[*Example 8*:
 ``` cpp
 namespace N {
   template<class T> class List {
   public:
 void g(Map<const char*,int>& m) {
   int i = m.get("Nicholas");
 }
 ```
+A call of `lt.get()` from `Map<const char*,int>::get()` would place
 `List<int>::get()` in the namespace `N` rather than in the global
 namespace.
 — *end example*]
 constraints are checked, and the instantiation of any template used in
 the default argument is done as if the default argument had been an
 initializer used in a function template specialization with the same
 scope, the same template parameters and the same access as that of the
 function template `f` used at that point, except that the scope in which
+a closure type is declared [[expr.prim.lambda.closure]] – and therefore
+its associated namespaces – remain as determined from the context of the
+definition for the default argument. This analysis is called *default
+argument instantiation*. The instantiated default argument is then used
+as the argument of `f`.
 Each default argument is instantiated independently.
+[*Example 9*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
 A zdef(A);
 void g(A a, A b, A c) {
   f(a, b, c);       // no default argument instantiation
   f(a, b);          // default argument z = zdef(T()) instantiated
+  f(a);             // error: ydef is not declared
 }
 ```
 — *end example*]
 The *noexcept-specifier* of a function template specialization is not
 instantiated along with the function declaration; it is instantiated
+when needed [[except.spec]]. If such an *noexcept-specifier* is needed
+but has not yet been instantiated, the dependent names are looked up,
+the semantics constraints are checked, and the instantiation of any
 template used in the *noexcept-specifier* is done as if it were being
 done as part of instantiating the declaration of the specialization at
 that point.
+[*Note 6*:  [[temp.point]] defines the point of instantiation of a
 template specialization. — *end note*]
 There is an *implementation-defined* quantity that specifies the limit
+on the total depth of recursive instantiations [[implimits]], which
 could involve more than one template. The result of an infinite
 recursion in instantiation is undefined.
+[*Example 10*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
 };
 ```
 — *end example*]
+The *type-constraint*s and *requires-clause* of a template
+specialization or member function are not instantiated along with the
+specialization or function itself, even for a member function of a local
+class; substitution into the atomic constraints formed from them is
+instead performed as specified in [[temp.constr.decl]] and
+[[temp.constr.atomic]] when determining whether the constraints are
+satisfied or as specified in [[temp.constr.decl]] when comparing
+declarations.
+[*Note 7*: The satisfaction of constraints is determined during
+template argument deduction [[temp.deduct]] and overload resolution
+[[over.match]]. — *end note*]
+[*Example 11*:
+``` cpp
+template<typename T> concept C = sizeof(T) > 2;
+template<typename T> concept D = C<T> && sizeof(T) > 4;
+template<typename T> struct S {
+  S() requires C<T> { }         // #1
+  S() requires D<T> { }         // #2
+};
+S<char> s1;                     // error: no matching constructor
+S<char[8]> s2;                  // OK, calls #2
+```
+When `S<char>` is instantiated, both constructors are part of the
+specialization. Their constraints are not satisfied, and they suppress
+the implicit declaration of a default constructor for `S<char>`
+[[class.default.ctor]], so there is no viable constructor for `s1`.
+— *end example*]
+[*Example 12*:
+``` cpp
+template<typename T> struct S1 {
+  template<typename U>
+    requires false
+  struct Inner1;                // ill-formed, no diagnostic required
+};
+template<typename T> struct S2 {
+  template<typename U>
+    requires (sizeof(T[-(int)sizeof(T)]) > 1)
+  struct Inner2;                // ill-formed, no diagnostic required
+};
+```
+The class `S1<T>::Inner1` is ill-formed, no diagnostic required, because
+it has no valid specializations. `S2` is ill-formed, no diagnostic
+required, since no substitution into the constraints of its `Inner2`
+template would result in a valid expression.
+— *end example*]
 ### Explicit instantiation <a id="temp.explicit">[[temp.explicit]]</a>
 A class, function, variable, or member template specialization can be
 explicitly instantiated from its template. A member function, member
 class or static data member of a class template can be explicitly
 instantiated from the member definition associated with its class
+template.
 The syntax for explicit instantiation is:
 ``` bnf
 explicit-instantiation:
+  externₒₚₜ template declaration
 ```
 There are two forms of explicit instantiation: an explicit instantiation
 definition and an explicit instantiation declaration. An explicit
 instantiation declaration begins with the `extern` keyword.
+An explicit instantiation shall not use a *storage-class-specifier*
+[[dcl.stc]] other than `thread_local`. An explicit instantiation of a
+function template, member function of a class template, or variable
+template shall not use the `inline`, `constexpr`, or `consteval`
+specifiers. No *attribute-specifier-seq* [[dcl.attr.grammar]] shall
+appertain to an explicit instantiation.
 If the explicit instantiation is for a class or member class, the
 *elaborated-type-specifier* in the *declaration* shall include a
+*simple-template-id*; otherwise, the *declaration* shall be a
+*simple-declaration* whose *init-declarator-list* comprises a single
+*init-declarator* that does not have an *initializer*. If the explicit
+instantiation is for a function or member function, the *unqualified-id*
+in the *declarator* shall be either a *template-id* or, where all
+template arguments can be deduced, a *template-name* or
+*operator-function-id*.
 [*Note 1*: The declaration may declare a *qualified-id*, in which case
 the *unqualified-id* of the *qualified-id* must be a
 *template-id*. — *end note*]
 If the explicit instantiation is for a member function, a member class
 or a static data member of a class template specialization, the name of
 the class template specialization in the *qualified-id* for the member
 name shall be a *simple-template-id*. If the explicit instantiation is
+for a variable template specialization, the *unqualified-id* in the
+*declarator* shall be a *simple-template-id*. An explicit instantiation
+shall appear in an enclosing namespace of its template. If the name
+declared in the explicit instantiation is an unqualified name, the
+explicit instantiation shall appear in the namespace where its template
+is declared or, if that namespace is inline [[namespace.def]], any
+namespace from its enclosing namespace set.
 [*Note 2*: Regarding qualified names in declarators, see
 [[dcl.meaning]]. — *end note*]
 [*Example 1*:
 class of a class template, or a member class template of a class or
 class template shall precede an explicit instantiation of that entity
 unless the explicit instantiation is preceded by an explicit
 specialization of the entity with the same template arguments. If the
 *declaration* of the explicit instantiation names an implicitly-declared
+special member function [[special]], the program is ill-formed.
+The *declaration* in an *explicit-instantiation* and the *declaration*
+produced by the corresponding substitution into the templated function,
+variable, or class are two declarations of the same entity.
+[*Note 3*:
+These declarations are required to have matching types as specified in
+[[basic.link]], except as specified in  [[except.spec]].
+[*Example 2*:
+``` cpp
+template<typename T> T var = {};
+template float var<float>;      // OK, instantiated variable has type float
+template int var<int[16]>[];    // OK, absence of major array bound is permitted
+template int *var<int>;         // error: instantiated variable has type int
+template<typename T> auto av = T();
+template int av<int>;           // OK, variable with type int can be redeclared with type auto
+template<typename T> auto f() {}
+template void f<int>();         // error: function with deduced return type
+                                // redeclared with non-deduced return type[dcl.spec.auto]
+```
+— *end example*]
+— *end note*]
+Despite its syntactic form, the *declaration* in an
+*explicit-instantiation* for a variable is not itself a definition and
+does not conflict with the definition instantiated by an explicit
+instantiation definition for that variable.
 For a given set of template arguments, if an explicit instantiation of a
 template appears after a declaration of an explicit specialization for
 that template, the explicit instantiation has no effect. Otherwise, for
+an explicit instantiation definition, the definition of a function
 template, a variable template, a member function template, or a member
 function or static data member of a class template shall be present in
 every translation unit in which it is explicitly instantiated.
 An explicit instantiation of a class, function template, or variable
 is defined. An explicit instantiation for a member of a class template
 is placed in the namespace where the enclosing class template is
 defined. An explicit instantiation for a member template is placed in
 the namespace where the enclosing class or class template is defined.
+[*Example 3*:
 ``` cpp
 namespace N {
   template<class T> class Y { void mf() { } };
 }
 — *end example*]
 A trailing *template-argument* can be left unspecified in an explicit
 instantiation of a function template specialization or of a member
 function template specialization provided it can be deduced from the
+type of a function parameter [[temp.deduct]].
+[*Example 4*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
 template void sort<>(Array<int>&);
 ```
 — *end example*]
+[*Note 4*: An explicit instantiation of a constrained template is
+required to satisfy that template’s associated constraints
+[[temp.constr.decl]]. The satisfaction of constraints is determined when
+forming the template name of an explicit instantiation in which all
+template arguments are specified [[temp.names]], or, for explicit
+instantiations of function templates, during template argument deduction
+[[temp.deduct.decl]] when one or more trailing template arguments are
+left unspecified. — *end note*]
 An explicit instantiation that names a class template specialization is
 also an explicit instantiation of the same kind (declaration or
 definition) of each of its members (not including members inherited from
 base classes and members that are templates) that has not been
 previously explicitly specialized in the translation unit containing the
+explicit instantiation, provided that the associated constraints, if
+any, of that member are satisfied by the template arguments of the
+explicit instantiation ([[temp.constr.decl]], [[temp.constr.constr]]),
+except as described below.
+[*Note 5*: In addition, it will typically be an explicit instantiation
 of certain implementation-dependent data about the class. — *end note*]
 An explicit instantiation definition that names a class template
 specialization explicitly instantiates the class template specialization
 and is an explicit instantiation definition of only those members that
 have been defined at the point of instantiation.
+An explicit instantiation of a prospective destructor [[class.dtor]]
+shall name the selected destructor of the class.
 If an entity is the subject of both an explicit instantiation
 declaration and an explicit instantiation definition in the same
 translation unit, the definition shall follow the declaration. An entity
 that is the subject of an explicit instantiation declaration and that is
+also used in a way that would otherwise cause an implicit instantiation
+[[temp.inst]] in the translation unit shall be the subject of an
+explicit instantiation definition somewhere in the program; otherwise
+the program is ill-formed, no diagnostic required.
+[*Note 6*: This rule does apply to inline functions even though an
 explicit instantiation declaration of such an entity has no other
 normative effect. This is needed to ensure that if the address of an
 inline function is taken in a translation unit in which the
 implementation chose to suppress the out-of-line body, another
 translation unit will supply the body. — *end note*]
 An explicit instantiation declaration shall not name a specialization of
 a template with internal linkage.
 An explicit instantiation does not constitute a use of a default
 argument, so default argument instantiation is not done.
+[*Example 5*:
 ``` cpp
 char* p = 0;
 template<class T> T g(T x = &p) { return x; }
 template int g<int>(int);       // OK even though &p isn't an int.
 can be declared by a declaration introduced by `template<>`; that is:
 ``` bnf
 explicit-specialization:
+  template '<' '>' declaration
 ```
 [*Example 1*:
 ``` cpp
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
 — *end example*]
+An explicit specialization shall not use a *storage-class-specifier*
+[[dcl.stc]] other than `thread_local`.
 An explicit specialization may be declared in any scope in which the
 corresponding primary template may be defined ([[namespace.memdef]],
 [[class.mem]], [[temp.mem]]).
 A declaration of a function template, class template, or variable
 data member template of a class template may be explicitly specialized
 for a class specialization that is implicitly instantiated; in this
 case, the definition of the class template shall precede the explicit
 specialization for the member of the class template. If such an explicit
 specialization for the member of a class template names an
+implicitly-declared special member function [[special]], the program is
+ill-formed.
 A member of an explicitly specialized class is not implicitly
 instantiated from the member declaration of the class template; instead,
 the member of the class template specialization shall itself be
 explicitly defined if its definition is required. In this case, the
 };
 template<> enum A<int>::E : int { eint };           // OK
 template<> enum class A<int>::S : int { sint };     // OK
 template<class T> enum A<T>::E : T { eT };
 template<class T> enum class A<T>::S : T { sT };
+template<> enum A<char>::E : char { echar };        // error: A<char>::E was instantiated
                                                     // when A<char> was instantiated
 template<> enum class A<char>::S : char { schar };  // OK
 ```
 — *end example*]
 — *end example*]
 A *simple-template-id* that names a class template explicit
 specialization that has been declared but not defined can be used
+exactly like the names of other incompletely-defined classes
+[[basic.types]].
 [*Example 6*:
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> void sort(Array<int>&);
 ```
 — *end example*]
+[*Note 2*: An explicit specialization of a constrained template is
+required to satisfy that template’s associated constraints
+[[temp.constr.decl]]. The satisfaction of constraints is determined when
+forming the template name of an explicit specialization in which all
+template arguments are specified [[temp.names]], or, for explicit
+specializations of function templates, during template argument
+deduction [[temp.deduct.decl]] when one or more trailing template
+arguments are left unspecified. — *end note*]
 A function with the same name as a template and a type that exactly
 matches that of a template specialization is not an explicit
+specialization [[temp.fct]].
+Whether an explicit specialization of a function or variable template is
+inline, constexpr, or an immediate function is determined by the
+explicit specialization and is independent of those properties of the
+template.
 [*Example 8*:
 ``` cpp
 template<class T> void f(T) { ... }
 An explicit specialization of a static data member of a template or an
 explicit specialization of a static data member template is a definition
 if the declaration includes an initializer; otherwise, it is a
 declaration.
+[*Note 3*:
 The definition of a static data member of a template that requires
 default-initialization must use a *braced-init-list*:
 ``` cpp
 In an explicit specialization declaration for a member of a class
 template or a member template that appears in namespace scope, the
 member template and some of its enclosing class templates may remain
 unspecialized, except that the declaration shall not explicitly
 specialize a class member template if its enclosing class templates are
+not explicitly specialized as well. In such an explicit specialization
 declaration, the keyword `template` followed by a
 *template-parameter-list* shall be provided instead of the `template<>`
 preceding the explicit specialization declaration of the member. The
 types of the *template-parameter*s in the *template-parameter-list*
 shall be the same as those specified in the primary template definition.
       template <class T> void mf1(T);
   };
 template <> template <> template<class T>
   void A<int>::B<double>::mf1(T t) { }
 template <class Y> template <>
+  void A<Y>::B<double>::mf2() { }       // error: B<double> is specialized but
                                         // its enclosing class template A is not
 ```
 — *end example*]
 - the explicit specialization of a function template;
 - the explicit specialization of a member function template;
 - the explicit specialization of a member function of a class template
   where the class template specialization to which the member function
+  specialization belongs is implicitly instantiated. \[*Note 4*: Default
   function arguments may be specified in the declaration or definition
   of a member function of a class template specialization that is
   explicitly specialized. — *end note*]

Diff to HTML by rtfpessoa