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

Files changed (1) hide show

tmp/tmpzybbk7yq/{from.md → to.md} +132 -214

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

@@ -1,7 +1,9 @@
 ## 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
@@ -20,16 +22,16 @@ 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*:
 ``` cpp
 template<class T = int> struct A {
@@ -65,23 +67,24 @@ For a given template and a given set of *template-argument*s,
   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.
@@ -167,13 +170,14 @@ 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;
@@ -219,21 +223,21 @@ 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;
   template<class Y> struct Inner<T, Y>;         // #1a
-  template<class Y> struct Inner<T, Y> { };     // #1b; OK: valid redeclaration of #1a
   template<class Y> struct Inner<U, Y> { };     // #2
 };
 Outer<int, int> outer;                          // error at #2
 ```
@@ -252,19 +256,18 @@ 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
@@ -279,11 +282,11 @@ 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*:
@@ -367,11 +370,11 @@ 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
@@ -379,67 +382,36 @@ instantiation of substatements of a constexpr if statement within its
 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:
-    T* get();
-  };
-}
-template<class K, class V> class Map {
-public:
-  N::List<V> lt;
-  V get(K);
-};
-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*]
-If a function template `f` is called in a way that requires a default
 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 9*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
@@ -470,11 +442,11 @@ 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
@@ -496,11 +468,11 @@ 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;
@@ -518,11 +490,11 @@ 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
@@ -572,33 +544,12 @@ 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*:
 ``` cpp
 template<class T> class Array { void mf(); };
@@ -614,26 +565,28 @@ namespace N {
 template void N::f<int>(int&);
 ```
 — *end example*]
-A declaration of a function template, a variable template, a member
-function or static data member of a class template, or a member function
-template of a class or class template shall precede an explicit
-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 [[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*:
@@ -667,41 +620,17 @@ 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
-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 3*:
-``` cpp
-namespace N {
-  template<class T> class Y { void mf() { } };
-}
-template class Y<int>;          // error: class template Y not visible in the global namespace
-using N::Y;
-template class Y<int>;          // error: explicit instantiation outside of the namespace of the template
-template class N::Y<char*>;             // OK: explicit instantiation in namespace N
-template void N::Y<double>::mf();       // OK: explicit instantiation in namespace N
-```
-— *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) { ... }
@@ -709,50 +638,49 @@ 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*]
@@ -761,11 +689,11 @@ 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.
@@ -814,65 +742,67 @@ 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 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
-template being explicitly specialized shall precede the declaration of
-the explicit specialization.
 [*Note 1*: A declaration, but not a definition of the template is
 required. — *end note*]
-The definition of a class or class template shall precede the
 declaration of an explicit specialization for a member template of the
 class or class template.
 [*Example 2*:
 ``` cpp
 template<> class X<int> { ... };          // error: X not a template
 template<class T> class X;
-template<> class X<char*> { ... };        // OK: X is a template
 ```
 — *end example*]
 A member function, a member function template, a member class, a member
 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 [[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
-definition of the class template explicit specialization shall be in
-scope at the point at which the member is defined. The definition of an
-explicitly specialized class is unrelated to the definition of a
-generated specialization. That is, its members need not have the same
-names, types, etc. as the members of a generated specialization. Members
-of an explicitly specialized class template are defined in the same
-manner as members of normal classes, and not using the `template<>`
-syntax. The same is true when defining a member of an explicitly
-specialized member class. However, `template<>` is used in defining a
-member of an explicitly specialized member class template that is
-specialized as a class template.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
@@ -918,20 +848,20 @@ template<class U> void A<short>::C<U>::f() { ... }    // error: template<> requi
 ```
 — *end example*]
 If a template, a member template or a member of a class template is
-explicitly specialized then that specialization shall be declared before
-the first use of that specialization that would cause an implicit
-instantiation to take place, in every translation unit in which such a
-use occurs; no diagnostic is required. If the program does not provide a
-definition for an explicit specialization and either the specialization
-is used in a way that would cause an implicit instantiation to take
-place or the member is a virtual member function, the program is
-ill-formed, no diagnostic required. An implicit instantiation is never
-generated for an explicit specialization that is declared but not
-defined.
 [*Example 4*:
 ``` cpp
 class String { };
@@ -941,11 +871,11 @@ template<class T> void sort(Array<T>& v) { ... }
 void f(Array<String>& v) {
   sort(v);          // use primary template sort(Array<T>&), T is String
 }
 template<> void sort<String>(Array<String>& v);     // error: specialization after use of primary template
-template<> void sort<>(Array<char*>& v);            // OK: sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
 template<> enum A<int>::E : int { eint };           // OK
@@ -976,52 +906,32 @@ can affect whether a program is well-formed according to the relative
 positioning of the explicit specialization declarations and their points
 of instantiation in the translation unit as specified above and below.
 When writing a specialization, be careful about its location; or to make
 it compile will be such a trial as to kindle its self-immolation.
-A template explicit specialization is in the scope of the namespace in
-which the template was defined.
-[*Example 5*:
-``` cpp
-namespace N {
-  template<class T> class X { ... };
-  template<class T> class Y { ... };
-  template<> class X<int> { ... };        // OK: specialization in same namespace
-  template<> class Y<double>;                   // forward-declare intent to specialize for double
-}
-template<> class N::Y<double> { ... };    // OK: specialization in enclosing namespace
-template<> class N::Y<short> { ... };     // OK: specialization in enclosing namespace
-```
-— *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<> class X<int>;
-X<int>* p;                                      // OK: pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
-provided it can be deduced from the function argument type.
-[*Example 7*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v);
@@ -1044,22 +954,29 @@ 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) { ... }
 template<class T> inline T g(T) { ... }
-template<> inline void f<>(int) { ... }   // OK: inline
-template<> int g<>(int) { ... }           // OK: not inline
 ```
 — *end example*]
 An explicit specialization of a static data member of a template or an
@@ -1067,28 +984,29 @@ 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
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
-template<> X Q<int>::x { }; // definition
 ```
 — *end note*]
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
-[*Example 9*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
@@ -1120,11 +1038,11 @@ template<> void A<int>::h(int) { }
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
-[*Example 10*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
@@ -1146,11 +1064,11 @@ 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.
-[*Example 11*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
@@ -1183,9 +1101,9 @@ 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 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*]

 ## Template instantiation and specialization <a id="temp.spec">[[temp.spec]]</a>
+### General <a id="temp.spec.general">[[temp.spec.general]]</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
 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 variable or class that is explicitly specialized
+shall be specified with a *simple-template-id*. In the explicit
 specialization declaration for a function template or a member function
+template, the function or member function explicitly specialized may be
+specified using a *template-id*.
 [*Example 1*:
 ``` cpp
 template<class T = int> struct 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
+ specialization is reachable from the explicit instantiation.
+An implementation is not required to diagnose a violation of this rule
+if neither declaration is reachable from the other.
 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) can 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.
 }
 ```
 — *end example*]
+If the template selected for the specialization
+[[temp.spec.partial.match]] has been declared, but not defined, at the
+point of instantiation [[temp.point]], the instantiation yields an
+incomplete class type [[term.incomplete.type]].
 [*Example 2*:
 ``` cpp
 template<class T> class X;
 — *end example*]
 However, for the purpose of determining whether an instantiated
 redeclaration is valid according to  [[basic.def.odr]] and
+[[class.mem]], an instantiated 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;
   template<class Y> struct Inner<T, Y>;         // #1a
+  template<class Y> struct Inner<T, Y> { };     // #1b; OK, valid redeclaration of #1a
   template<class Y> struct Inner<U, Y> { };     // #2
 };
 Outer<int, int> outer;                          // error at #2
 ```
 Friendly<float> ff;                             // error: produces second definition of f(U)
 ```
 — *end example*]
+Unless a member of a templated class 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
 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
+[[term.odr.use]] 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*:
 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 or static data member of a templated class, 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
 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 or default member
+initializer shall not cause the template to be implicitly instantiated
+except where needed to determine the correctness of the default argument
+or default member initializer. The use of a default argument in a
 function call causes specializations in the default argument to be
+implicitly instantiated. Similarly, the use of a default member
+initializer in a constructor definition or an aggregate initialization
+causes specializations in the default member initializer to be
+instantiated.
+If a templated function `f` is called in a way that requires a default
 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 8*:
 ``` cpp
 template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
 class  A { };
 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 9*:
 ``` cpp
 template<class T> class X {
   X<T>* p;          // OK
   X<T*> a;          // implicit generation of X<T> requires
 [*Note 7*: The satisfaction of constraints is determined during
 template argument deduction [[temp.deduct]] and overload resolution
 [[over.match]]. — *end note*]
+[*Example 10*:
 ``` cpp
 template<typename T> concept C = sizeof(T) > 2;
 template<typename T> concept D = C<T> && sizeof(T) > 4;
 the implicit declaration of a default constructor for `S<char>`
 [[class.default.ctor]], so there is no viable constructor for `s1`.
 — *end example*]
+[*Example 11*:
 ``` cpp
 template<typename T> struct S1 {
   template<typename U>
     requires false
 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 variable template specialization, the
+*unqualified-id* in the *declarator* shall be a *simple-template-id*.
 [*Example 1*:
 ``` cpp
 template<class T> class Array { void mf(); };
 template void N::f<int>(int&);
 ```
 — *end example*]
+An explicit instantiation does not introduce a name
+[[basic.scope.scope]]. A declaration of a function template, a variable
+template, a member function or static data member of a class template,
+or a member function template of a class or class template shall be
+reachable from any explicit 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 be reachable from any
+explicit instantiation of that entity unless an explicit specialization
+of the entity with the same template arguments is reachable therefrom.
+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 1*:
 These declarations are required to have matching types as specified in
 [[basic.link]], except as specified in  [[except.spec]].
 [*Example 2*:
 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.
 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
+[[temp.deduct.decl]]. If all template arguments can be deduced, the
+empty template argument list `<>` may be omitted.
+[*Example 3*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v) { ... }
 template void sort<>(Array<int>&);
 ```
 — *end example*]
+[*Note 2*: 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 direct non-template members 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 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.
 An explicit instantiation of a prospective destructor [[class.dtor]]
+shall correspond to 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 4*: 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*]
 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 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.
 `Array<char*>`; other `Array` types will be sorted by functions
 generated from the template.
 — *end example*]
+The *declaration* in an *explicit-specialization* shall not be an
+*export-declaration*. 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
+[[dcl.meaning]], [[class.mem]], [[temp.mem]].
+An explicit specialization does not introduce a name
+[[basic.scope.scope]]. A declaration of a function template, class
+template, or variable template being explicitly specialized shall be
+reachable from the declaration of the explicit specialization.
 [*Note 1*: A declaration, but not a definition of the template is
 required. — *end note*]
+The definition of a class or class template shall be reachable from the
 declaration of an explicit specialization for a member template of the
 class or class template.
 [*Example 2*:
 ``` cpp
 template<> class X<int> { ... };          // error: X not a template
 template<class T> class X;
+template<> class X<char*> { ... };        // OK, X is a template
 ```
 — *end example*]
 A member function, a member function template, a member class, a member
 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 be reachable from 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. The definition of the
+class template explicit specialization shall be reachable from the
+definition of any member of it. The definition of an explicitly
+specialized class is unrelated to the definition of a generated
+specialization. That is, its members need not have the same names,
+types, etc. as the members of a generated specialization. Members of an
+explicitly specialized class template are defined in the same manner as
+members of normal classes, and not using the `template<>` syntax. The
+same is true when defining a member of an explicitly specialized member
+class. However, `template<>` is used in defining a member of an
+explicitly specialized member class template that is specialized as a
+class template.
 [*Example 3*:
 ``` cpp
 template<class T> struct A {
 ```
 — *end example*]
 If a template, a member template or a member of a class template is
+explicitly specialized, a declaration of that specialization shall be
+reachable from every use of that specialization that would cause an
+implicit instantiation to take place, in every translation unit in which
+such a use occurs; no diagnostic is required. If the program does not
+provide a definition for an explicit specialization and either the
+specialization is used in a way that would cause an implicit
+instantiation to take place or the member is a virtual member function,
+the program is ill-formed, no diagnostic required. An implicit
+instantiation is never generated for an explicit specialization that is
+declared but not defined.
 [*Example 4*:
 ``` cpp
 class String { };
 void f(Array<String>& v) {
   sort(v);          // use primary template sort(Array<T>&), T is String
 }
 template<> void sort<String>(Array<String>& v);     // error: specialization after use of primary template
+template<> void sort<>(Array<char*>& v);            // OK, sort<char*> not yet used
 template<class T> struct A {
   enum E : T;
   enum class S : T;
 };
 template<> enum A<int>::E : int { eint };           // OK
 positioning of the explicit specialization declarations and their points
 of instantiation in the translation unit as specified above and below.
 When writing a specialization, be careful about its location; or to make
 it compile will be such a trial as to kindle its self-immolation.
 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 5*:
 ``` cpp
 template<class T> class X;                      // X is a class template
 template<> class X<int>;
+X<int>* p;                                      // OK, pointer to declared class X<int>
 X<int> x;                                       // error: object of incomplete class X<int>
 ```
 — *end example*]
 A trailing *template-argument* can be left unspecified in the
 *template-id* naming an explicit function template specialization
+provided it can be deduced [[temp.deduct.decl]].
+[*Example 6*:
 ``` cpp
 template<class T> class Array { ... };
 template<class T> void sort(Array<T>& v);
 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, constinit, or consteval is determined by the explicit
+specialization and is independent of those properties of the template.
+Similarly, attributes appearing in the declaration of a template have no
+effect on an explicit specialization of that template.
+[*Example 7*:
 ``` cpp
 template<class T> void f(T) { ... }
 template<class T> inline T g(T) { ... }
+template<> inline void f<>(int) { ... }   // OK, inline
+template<> int g<>(int) { ... }           // OK, not inline
+template<typename> [[noreturn]] void h([[maybe_unused]] int i);
+template<> void h<int>(int i) {
+    // Implementations are expected not to warn that the function returns
+    // but can warn about the unused parameter.
+}
 ```
 — *end example*]
 An explicit specialization of a static data member of a template or an
 if the declaration includes an initializer; otherwise, it is a
 declaration.
 [*Note 3*:
+The definition of a static data member of a template for which
+default-initialization is desired can use functional cast notation
+[[expr.type.conv]]:
 ``` cpp
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
+template<> X Q<int>::x = X(); // definition
 ```
 — *end note*]
 A member or a member template of a class template may be explicitly
 specialized for a given implicit instantiation of the class template,
 even if the member or member template is defined in the class template
 definition. An explicit specialization of a member or member template is
 specified using the syntax for explicit specialization.
+[*Example 8*:
 ``` cpp
 template<class T> struct A {
   void f(T);
   template<class X1> void g1(T, X1);
 A member or a member template may be nested within many enclosing class
 templates. In an explicit specialization for such a member, the member
 declaration shall be preceded by a `template<>` for each enclosing class
 template that is explicitly specialized.
+[*Example 9*:
 ``` cpp
 template<class T1> class A {
   template<class T2> class B {
     void mf();
 *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.
+[*Example 10*:
 ``` cpp
 template <class T1> class A {
   template<class T2> class B {
     template<class T3> void mf1(T3);
 - 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 can 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