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

Files changed (1) hide show

tmp/tmp5qmhtxrn/{from.md → to.md} +111 -58

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

@@ -9,25 +9,35 @@ declaration-seq:
     declaration-seq declaration
 ```
 ``` bnf
 declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
     template-declaration
     deduction-guide
-    explicit-instantiation
-    explicit-specialization
-    export-declaration
     linkage-specification
     namespace-definition
     empty-declaration
     attribute-declaration
     module-import-declaration
 ```
 ``` bnf
 block-declaration:
     simple-declaration
     asm-declaration
     namespace-alias-definition
@@ -79,10 +89,16 @@ attribute-declaration:
 [[temp.deduct.guide]]; *namespace-definition*s are described in
 [[namespace.def]], *using-declaration*s are described in
 [[namespace.udecl]] and *using-directive*s are described in
 [[namespace.udir]]. — *end note*]
 A *simple-declaration* or *nodeclspec-function-declaration* of the form
 ``` bnf
 attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 ```
@@ -93,109 +109,146 @@ are described in  [[dcl.spec]]. *declarator*s, the components of an
 *init-declarator-list*, are described in [[dcl.decl]]. The
 *attribute-specifier-seq* appertains to each of the entities declared by
 the *declarator*s of the *init-declarator-list*.
 [*Note 2*: In the declaration for an entity, attributes appertaining to
-that entity may appear at the start of the declaration and after the
 *declarator-id* for that declaration. — *end note*]
 [*Example 1*:
 ``` cpp
 [[noreturn]] void f [[noreturn]] ();    // OK
 ```
 — *end example*]
-Except where otherwise specified, the meaning of an
-*attribute-declaration* is *implementation-defined*.
-A declaration occurs in a scope [[basic.scope]]; the scope rules are
-summarized in  [[basic.lookup]]. A declaration that declares a function
-or defines a class, namespace, template, or function also has one or
-more scopes nested within it. These nested scopes, in turn, can have
-declarations nested within them. Unless otherwise stated, utterances in
-[[dcl.dcl]] about components in, of, or contained by a declaration or
-subcomponent thereof refer only to those components of the declaration
-that are *not* nested within scopes nested within the declaration.
 In a *simple-declaration*, the optional *init-declarator-list* can be
-omitted only when declaring a class [[class]] or enumeration
 [[dcl.enum]], that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key*
 [[class.name]], or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
-*decl-specifier-seq*, the identifiers in these specifiers are among the
-names being declared by the declaration (as *class-name*s, *enum-name*s,
-or *enumerator*s, depending on the syntax). In such cases, the
-*decl-specifier-seq* shall introduce one or more names into the program,
-or shall redeclare a name introduced by a previous declaration.
 [*Example 2*:
 ``` cpp
 enum { };           // error
 typedef class { };  // error
 ```
 — *end example*]
-In a *static_assert-declaration*, the *constant-expression* shall be a
-contextually converted constant expression of type `bool`
-[[expr.const]]. If the value of the expression when so converted is
-`true`, the declaration has no effect. Otherwise, the program is
-ill-formed, and the resulting diagnostic message [[intro.compliance]]
-shall include the text of the *string-literal*, if one is supplied,
-except that characters not in the basic source character set
-[[lex.charset]] are not required to appear in the diagnostic message.
-[*Example 3*:
-``` cpp
-static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
-```
-— *end example*]
-An *empty-declaration* has no effect.
 A *simple-declaration* with an *identifier-list* is called a *structured
-binding declaration* [[dcl.struct.bind]]. If the *decl-specifier-seq*
-contains any *decl-specifier* other than `static`, `thread_local`,
-`auto` [[dcl.spec.auto]], or *cv-qualifier*s, the program is ill-formed.
 The *initializer* shall be of the form “`=` *assignment-expression*”, of
 the form “`{` *assignment-expression* `}`”, or of the form “`(`
 *assignment-expression* `)`”, where the *assignment-expression* is of
 array or non-union class type.
-Each *init-declarator* in the *init-declarator-list* contains exactly
-one *declarator-id*, which is the name declared by that
-*init-declarator* and hence one of the names declared by the
-declaration. The *defining-type-specifier*s [[dcl.type]] in the
-*decl-specifier-seq* and the recursive *declarator* structure of the
-*init-declarator* describe a type [[dcl.meaning]], which is then
-associated with the name being declared by the *init-declarator*.
 If the *decl-specifier-seq* contains the `typedef` specifier, the
-declaration is called a *typedef declaration* and the name of each
-*init-declarator* is declared to be a *typedef-name*, synonymous with
-its associated type [[dcl.typedef]]. If the *decl-specifier-seq*
-contains no `typedef` specifier, the declaration is called a *function
-declaration* if the type associated with the name is a function type
-[[dcl.fct]] and an *object declaration* otherwise.
 Syntactic components beyond those found in the general form of
-declaration are added to a function declaration to make a
 *function-definition*. An object declaration, however, is also a
 definition unless it contains the `extern` specifier and has no
 initializer [[basic.def]]. An object definition causes storage of
 appropriate size and alignment to be reserved and any appropriate
 initialization [[dcl.init]] to be done.
 A *nodeclspec-function-declaration* shall declare a constructor,
 destructor, or conversion function.
-[*Note 3*: A *nodeclspec-function-declaration* can only be used in a
 *template-declaration* [[temp.pre]], *explicit-instantiation*
 [[temp.explicit]], or *explicit-specialization*
 [[temp.expl.spec]]. — *end note*]

     declaration-seq declaration
 ```
 ``` bnf
 declaration:
+    name-declaration
+    special-declaration
+```
+``` bnf
+name-declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
     template-declaration
     deduction-guide
     linkage-specification
     namespace-definition
     empty-declaration
     attribute-declaration
     module-import-declaration
 ```
+``` bnf
+special-declaration:
+    explicit-instantiation
+    explicit-specialization
+    export-declaration
+```
 ``` bnf
 block-declaration:
     simple-declaration
     asm-declaration
     namespace-alias-definition
 [[temp.deduct.guide]]; *namespace-definition*s are described in
 [[namespace.def]], *using-declaration*s are described in
 [[namespace.udecl]] and *using-directive*s are described in
 [[namespace.udir]]. — *end note*]
+Certain declarations contain one or more scopes [[basic.scope.scope]].
+Unless otherwise stated, utterances in [[dcl.dcl]] about components in,
+of, or contained by a declaration or subcomponent thereof refer only to
+those components of the declaration that are *not* nested within scopes
+nested within the declaration.
 A *simple-declaration* or *nodeclspec-function-declaration* of the form
 ``` bnf
 attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 ```
 *init-declarator-list*, are described in [[dcl.decl]]. The
 *attribute-specifier-seq* appertains to each of the entities declared by
 the *declarator*s of the *init-declarator-list*.
 [*Note 2*: In the declaration for an entity, attributes appertaining to
+that entity can appear at the start of the declaration and after the
 *declarator-id* for that declaration. — *end note*]
 [*Example 1*:
 ``` cpp
 [[noreturn]] void f [[noreturn]] ();    // OK
 ```
 — *end example*]
+If a *declarator-id* is a name, the *init-declarator* and (hence) the
+declaration introduce that name.
+[*Note 3*: Otherwise, the *declarator-id* is a *qualified-id* or names
+a destructor or its *unqualified-id* is a *template-id* and no name is
+introduced. — *end note*]
+The *defining-type-specifier*s [[dcl.type]] in the *decl-specifier-seq*
+and the recursive *declarator* structure describe a type
+[[dcl.meaning]], which is then associated with the *declarator-id*.
 In a *simple-declaration*, the optional *init-declarator-list* can be
+omitted only when declaring a class [[class.pre]] or enumeration
 [[dcl.enum]], that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key*
 [[class.name]], or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
+*decl-specifier-seq*, the identifiers in these specifiers are also
+declared (as *class-name*s, *enum-name*s, or *enumerator*s, depending on
+the syntax). In such cases, the *decl-specifier-seq* shall (re)introduce
+one or more names into the program.
 [*Example 2*:
 ``` cpp
 enum { };           // error
 typedef class { };  // error
 ```
 — *end example*]
 A *simple-declaration* with an *identifier-list* is called a *structured
+binding declaration* [[dcl.struct.bind]]. Each *decl-specifier* in the
+*decl-specifier-seq* shall be `static`, `thread_local`, `auto`
+[[dcl.spec.auto]], or a *cv-qualifier*.
+[*Example 3*:
+``` cpp
+template<class T> concept C = true;
+C auto [x, y] = std::pair{1, 2};    // error: constrained placeholder-type-specifier
+                                    // not permitted for structured bindings
+```
+— *end example*]
 The *initializer* shall be of the form “`=` *assignment-expression*”, of
 the form “`{` *assignment-expression* `}`”, or of the form “`(`
 *assignment-expression* `)`”, where the *assignment-expression* is of
 array or non-union class type.
 If the *decl-specifier-seq* contains the `typedef` specifier, the
+declaration is a *typedef declaration* and each *declarator-id* is
+declared to be a *typedef-name*, synonymous with its associated type
+[[dcl.typedef]].
+[*Note 4*: Such a *declarator-id* is an *identifier*
+[[class.conv.fct]]. — *end note*]
+Otherwise, if the type associated with a *declarator-id* is a function
+type [[dcl.fct]], the declaration is a *function declaration*.
+Otherwise, if the type associated with a *declarator-id* is an object or
+reference type, the declaration is an *object declaration*. Otherwise,
+the program is ill-formed.
+[*Example 4*:
+``` cpp
+int f(), x;             // OK, function declaration for f and object declaration for x
+extern void g(),        // OK, function declaration for g
+  y;                    // error: void is not an object type
+```
+— *end example*]
 Syntactic components beyond those found in the general form of
+*simple-declaration* are added to a function declaration to make a
 *function-definition*. An object declaration, however, is also a
 definition unless it contains the `extern` specifier and has no
 initializer [[basic.def]]. An object definition causes storage of
 appropriate size and alignment to be reserved and any appropriate
 initialization [[dcl.init]] to be done.
 A *nodeclspec-function-declaration* shall declare a constructor,
 destructor, or conversion function.
+[*Note 5*: Because a member function cannot be subject to a
+non-defining declaration outside of a class definition [[class.mfct]], a
+*nodeclspec-function-declaration* can only be used in a
 *template-declaration* [[temp.pre]], *explicit-instantiation*
 [[temp.explicit]], or *explicit-specialization*
 [[temp.expl.spec]]. — *end note*]
+In a *static_assert-declaration*, the *constant-expression* is
+contextually converted to `bool` and the converted expression shall be a
+constant expression [[expr.const]]. If the value of the expression when
+so converted is `true` or the expression is evaluated in the context of
+a template definition, the declaration has no effect. Otherwise, the
+*static_assert-declaration* *fails*, the program is ill-formed, and the
+resulting diagnostic message [[intro.compliance]] should include the
+text of the *string-literal*, if one is supplied.
+[*Example 5*:
+``` cpp
+static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
+static_assert(sizeof(int[2]));          // OK, narrowing allowed
+template <class T>
+void f(T t) {
+  if constexpr (sizeof(T) == sizeof(int)) {
+    use(t);
+  } else {
+    static_assert(false, "must be int-sized");
+  }
+}
+void g(char c) {
+  f(0);                                 // OK
+  f(c);                                 // error on implementations where sizeof(int) > 1: must be int-sized
+}
+```
+— *end example*]
+An *empty-declaration* has no effect.
+Except where otherwise specified, the meaning of an
+*attribute-declaration* is *implementation-defined*.

Diff to HTML by rtfpessoa