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

Files changed (1) hide show

tmp/tmp5e8xgu9k/{from.md → to.md} +34 -33

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

@@ -36,11 +36,11 @@ constraint-logical-and-expression:
   primary-expression
   constraint-logical-and-expression '&&' primary-expression
 ```
 [*Note 1*: The `>` token following the *template-parameter-list* of a
-*template-declaration* may be the product of replacing a `>{>}` token by
 two consecutive `>` tokens [[temp.names]]. — *end note*]
 The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
@@ -76,49 +76,44 @@ struct matrix_constants {
 };
 ```
 — *end example*]
-A *template-declaration* can appear only as a namespace scope or class
-scope declaration. Its *declaration* shall not be an
-*export-declaration*. In a function template declaration, the last
-component of the *declarator-id* shall not be a *template-id*.
-[*Note 2*: That last component may be an *identifier*, an
-*operator-function-id*, a *conversion-function-id*, or a
-*literal-operator-id*. In a class template declaration, if the class
-name is a *simple-template-id*, the declaration declares a class
-template partial specialization [[temp.class.spec]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
 instantiation the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
-A template name has linkage [[basic.link]]. Specializations (explicit or
-implicit) of a template that has internal linkage are distinct from all
-specializations in other translation units. A template, a template
-explicit specialization [[temp.expl.spec]], and a class template partial
-specialization shall not have C linkage. Use of a linkage specification
-other than `"C"` or `"C++"` with any of these constructs is
-conditionally-supported, with *implementation-defined* semantics.
-Template definitions shall obey the one-definition rule
-[[basic.def.odr]].
-[*Note 3*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
-of template instantiation [[temp.decls]] and must also obey the
-one-definition rule. — *end note*]
-A class template shall not have the same name as any other template,
-class, function, variable, enumeration, enumerator, namespace, or type
-in the same scope [[basic.scope]], except as specified in
-[[temp.class.spec]]. Except that a function template can be overloaded
-either by non-template functions [[dcl.fct]] with the same name or by
-other function templates with the same name [[temp.over]], a template
-name declared in namespace scope or in class scope shall be unique in
-that scope.
 An entity is *templated* if it is
 - a template,
 - an entity defined [[basic.def]] or created [[class.temporary]] in a
@@ -126,23 +121,29 @@ An entity is *templated* if it is
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
-[*Note 4*: A local class, a local variable, or a friend function
-defined in a templated entity is a templated entity. — *end note*]
 A *template-declaration* is written in terms of its template parameters.
 The optional *requires-clause* following a *template-parameter-list*
 allows the specification of constraints [[temp.constr.decl]] on template
 arguments [[temp.arg]]. The *requires-clause* introduces the
 *constraint-expression* that results from interpreting the
 *constraint-logical-or-expression* as a *constraint-expression*. The
 *constraint-logical-or-expression* of a *requires-clause* is an
 unevaluated operand [[expr.context]].
-[*Note 5*:
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.

   primary-expression
   constraint-logical-and-expression '&&' primary-expression
 ```
 [*Note 1*: The `>` token following the *template-parameter-list* of a
+*template-declaration* can be the product of replacing a `>>` token by
 two consecutive `>` tokens [[temp.names]]. — *end note*]
 The *declaration* in a *template-declaration* (if any) shall
 - declare or define a function, a class, or a variable, or
 };
 ```
 — *end example*]
+[*Note 2*: A *template-declaration* can appear only as a namespace
+scope or class scope declaration. — *end note*]
+Its *declaration* shall not be an *export-declaration*. In a function
+template declaration, the *unqualified-id* of the *declarator-id* shall
+be a name.
+[*Note 3*: A class or variable template declaration of a
+*simple-template-id* declares a partial specialization
+[[temp.spec.partial]]. — *end note*]
 In a *template-declaration*, explicit specialization, or explicit
 instantiation the *init-declarator-list* in the declaration shall
 contain at most one declarator. When such a declaration is used to
 declare a class template, no declarator is permitted.
+A specialization (explicit or implicit) of one template is distinct from
+all specializations of any other template. A template, an explicit
+specialization [[temp.expl.spec]], and a partial specialization shall
+not have C language linkage.
+[*Note 4*: Default arguments for function templates and for member
 functions of class templates are considered definitions for the purpose
+of template instantiation [[temp.decls]] and must obey the
+one-definition rule [[basic.def.odr]]. — *end note*]
+[*Note 5*: A template cannot have the same name as any other name bound
+in the same scope [[basic.scope.scope]], except that a function template
+can share a name with non-template functions [[dcl.fct]] and/or function
+templates [[temp.over]]. Specializations, including partial
+specializations [[temp.spec.partial]], do not reintroduce or bind names.
+Their target scope is the target scope of the primary template, so all
+specializations of a template belong to the same scope as it
+does. — *end note*]
 An entity is *templated* if it is
 - a template,
 - an entity defined [[basic.def]] or created [[class.temporary]] in a
 - a member of a templated entity,
 - an enumerator for an enumeration that is a templated entity, or
 - the closure type of a *lambda-expression* [[expr.prim.lambda.closure]]
   appearing in the declaration of a templated entity.
+[*Note 6*: A local class, a local or block variable, or a friend
+function defined in a templated entity is a templated
+entity. — *end note*]
+A *templated function* is a function template or a function that is
+templated. A *templated class* is a class template or a class that is
+templated. A *templated variable* is a variable template or a variable
+that is templated.
 A *template-declaration* is written in terms of its template parameters.
 The optional *requires-clause* following a *template-parameter-list*
 allows the specification of constraints [[temp.constr.decl]] on template
 arguments [[temp.arg]]. The *requires-clause* introduces the
 *constraint-expression* that results from interpreting the
 *constraint-logical-or-expression* as a *constraint-expression*. The
 *constraint-logical-or-expression* of a *requires-clause* is an
 unevaluated operand [[expr.context]].
+[*Note 7*:
 The expression in a *requires-clause* uses a restricted grammar to avoid
 ambiguities. Parentheses can be used to specify arbitrary expressions in
 a *requires-clause*.

Diff to HTML by rtfpessoa