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

Files changed (1) hide show

tmp/tmpgcy0rlki/{from.md → to.md} +129 -26

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

@@ -3,12 +3,11 @@
 Declarations generally specify how names are to be interpreted.
 Declarations have the form
 ``` bnf
 declaration-seq:
-    declaration
-    declaration-seq declaration
 ```
 ``` bnf
 declaration:
     name-declaration
@@ -18,10 +17,11 @@ declaration:
 ``` bnf
 name-declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
     template-declaration
     deduction-guide
     linkage-specification
     namespace-definition
     empty-declaration
@@ -43,10 +43,11 @@ block-declaration:
     namespace-alias-definition
     using-declaration
     using-enum-declaration
     using-directive
     static_assert-declaration
     alias-declaration
     opaque-enum-declaration
 ```
 ``` bnf
@@ -57,21 +58,48 @@ nodeclspec-function-declaration:
 ``` bnf
 alias-declaration:
     using identifier attribute-specifier-seqₒₚₜ '=' defining-type-id ';'
 ```
 ``` bnf
 simple-declaration:
     decl-specifier-seq init-declarator-listₒₚₜ ';'
     attribute-specifier-seq decl-specifier-seq init-declarator-list ';'
- attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ '[' identifier-list ']' initializer ';'
 ```
 ``` bnf
 static_assert-declaration:
   static_assert '(' constant-expression ')' ';'
-  static_assert '(' constant-expression ',' string-literal ')' ';'
 ```
 ``` bnf
 empty-declaration:
     ';'
@@ -90,15 +118,18 @@ attribute-declaration:
 [[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ₒₚₜ ';'
 ```
@@ -151,14 +182,18 @@ 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;
@@ -168,17 +203,18 @@ C auto [x, y] = std::pair{1, 2};    // error: constrained placeholder-type-speci
 — *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
@@ -195,36 +231,71 @@ 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");
@@ -245,10 +316,42 @@ void g(char c) {
 }
 ```
 — *end example*]
 An *empty-declaration* has no effect.
 Except where otherwise specified, the meaning of an
 *attribute-declaration* is *implementation-defined*.

 Declarations generally specify how names are to be interpreted.
 Declarations have the form
 ``` bnf
 declaration-seq:
+    declaration declaration-seqₒₚₜ
 ```
 ``` bnf
 declaration:
     name-declaration
 ``` bnf
 name-declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
+    friend-type-declaration
     template-declaration
     deduction-guide
     linkage-specification
     namespace-definition
     empty-declaration
     namespace-alias-definition
     using-declaration
     using-enum-declaration
     using-directive
     static_assert-declaration
+    consteval-block-declaration
     alias-declaration
     opaque-enum-declaration
 ```
 ``` bnf
 ``` bnf
 alias-declaration:
     using identifier attribute-specifier-seqₒₚₜ '=' defining-type-id ';'
 ```
+``` bnf
+sb-identifier:
+    '...'ₒₚₜ identifier attribute-specifier-seqₒₚₜ
+```
+``` bnf
+sb-identifier-list:
+    sb-identifier
+    sb-identifier-list ',' sb-identifier
+```
+``` bnf
+structured-binding-declaration:
+    attribute-specifier-seqₒₚₜ decl-specifier-seq ref-qualifierₒₚₜ '[' sb-identifier-list ']'
+```
 ``` bnf
 simple-declaration:
     decl-specifier-seq init-declarator-listₒₚₜ ';'
     attribute-specifier-seq decl-specifier-seq init-declarator-list ';'
+ structured-binding-declaration initializer ';'
+```
+``` bnf
+static_assert-message:
+  unevaluated-string
+  constant-expression
 ```
 ``` bnf
 static_assert-declaration:
   static_assert '(' constant-expression ')' ';'
+  static_assert '(' constant-expression ',' static_assert-message ')' ';'
+```
+``` bnf
+consteval-block-declaration:
+  consteval compound-statement
 ```
 ``` bnf
 empty-declaration:
     ';'
 [[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]] 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.
+If a *name-declaration* matches the syntactic requirements of
+*friend-type-declaration*, it is a *friend-type-declaration*.
 A *simple-declaration* or *nodeclspec-function-declaration* of the form
 ``` bnf
 attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 ```
 typedef class { };  // error
 ```
 — *end example*]
+A *simple-declaration* or a *condition* with a
+*structured-binding-declaration* is called a *structured binding
+declaration* [[dcl.struct.bind]]. Each *decl-specifier* in the
+*decl-specifier-seq* shall be `constexpr`, `constinit`, `static`,
+`thread_local`, `auto` [[dcl.spec.auto]], or a *cv-qualifier*. The
+declaration shall contain at most one *sb-identifier* whose *identifier*
+is preceded by an ellipsis. If the declaration contains any such
+*sb-identifier*, it shall declare a templated entity [[temp.pre]].
 [*Example 3*:
 ``` cpp
 template<class T> concept C = true;
 — *end example*]
 The *initializer* shall be of the form “`=` *assignment-expression*”, of
 the form “`{` *assignment-expression* `}`”, or of the form “`(`
+*assignment-expression* `)`”. If the *structured-binding-declaration*
+appears as a *condition*, the *assignment-expression* shall be of
+non-union class type. Otherwise, the *assignment-expression* shall be 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* [[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
   y;                    // error: void is not an object type
 ```
 — *end example*]
+An object definition causes storage of appropriate size and alignment to
+be reserved and any appropriate initialization [[dcl.init]] to be done.
 Syntactic components beyond those found in the general form of
 *simple-declaration* are added to a function declaration to make a
+*function-definition*. A token sequence starting with `{` or `=` is
+treated as a *function-body* [[dcl.fct.def.general]] if the type of the
+*declarator-id* [[dcl.meaning.general]] is a function type, and is
+otherwise treated as a *brace-or-equal-initializer*
+[[dcl.init.general]].
+[*Note 5*: If the declaration acquires a function type through template
+instantiation, the program is ill-formed; see [[temp.spec.general]]. The
+function type of a function definition cannot be specified with a
+*typedef-name* [[dcl.fct]]. — *end note*]
 A *nodeclspec-function-declaration* shall declare a constructor,
 destructor, or conversion function.
+[*Note 6*: 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*]
+If a *static_assert-message* matches the syntactic requirements of
+*unevaluated-string*, it is an *unevaluated-string* and the text of the
+*static_assert-message* is the text of the *unevaluated-string*.
+Otherwise, a *static_assert-message* shall be an expression M such that
+- the expression `M.size()` is implicitly convertible to the type
+  `std::size_t`, and
+- the expression `M.data()` is implicitly convertible to the type
+  “pointer to `const char`”.
+In a *static_assert-declaration*, the *constant-expression* E is
 contextually converted to `bool` and the converted expression shall be a
+constant expression [[expr.const]]. If the value of the expression E
+when so converted is `true` or the expression is evaluated in the
+context of a template definition, the declaration has no effect and the
+*static_assert-message* is an unevaluated operand
+[[term.unevaluated.operand]]. Otherwise, the *static_assert-declaration*
+*fails* and
+- the program is ill-formed, and
+- if the *static_assert-message* is a *constant-expression* M,
+  - `M.size()` shall be a converted constant expression of type
+    `std::size_t` and let N denote the value of that expression,
+  - `M.data()`, implicitly converted to the type “pointer to
+    `const char`”, shall be a core constant expression and let D denote
+    the converted expression,
+  - for each i where 0 ≤ i < N, `D[i]` shall be an integral constant
+    expression, and
+  - the text of the *static_assert-message* is formed by the sequence of
+    N code units, starting at D, of the ordinary literal encoding
+    [[lex.charset]].
+*Recommended practice:* When a *static_assert-declaration* fails, the
+resulting diagnostic message should include the text of the
+*static_assert-message*, if one is supplied.
 [*Example 5*:
 ``` cpp
 static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
 }
 ```
 — *end example*]
+For a *consteval-block-declaration* D, the expression E corresponding to
+D is:
+``` cpp
+[]static consteval -> void compound-statement ()
+```
+E shall be a constant expression [[expr.const]].
+[*Note 7*: The evaluation of the expression corresponding to a
+*consteval-block-declaration* [[lex.phases]] can produce injected
+declarations as side effects. — *end note*]
+[*Example 6*:
+``` cpp
+struct S;
+consteval {
+  std::meta::define_aggregate(^^S, {});     // OK
+  template<class T>
+  struct X { };                             // error: local templates are not allowed
+  template<class T>
+  concept C = true;                         // error: local concepts are not allowed
+  return;                                   // OK
+}
+```
+— *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