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

Files changed (1) hide show

tmp/tmpfyuvfhy1/{from.md → to.md} +227 -141

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

@@ -1,20 +1,22 @@
 ## Attributes <a id="dcl.attr">[[dcl.attr]]</a>
 ### Attribute syntax and semantics <a id="dcl.attr.grammar">[[dcl.attr.grammar]]</a>
-Attributes specify additional information for various source constructs
-such as types, variables, names, blocks, or translation units.
 ``` bnf
 attribute-specifier-seq:
-  attribute-specifier-seqₒₚₜ attribute-specifier
 ```
 ``` bnf
 attribute-specifier:
   '[' '[' attribute-using-prefixₒₚₜ attribute-list ']' ']'
   alignment-specifier
 ```
 ``` bnf
 alignment-specifier:
@@ -33,15 +35,26 @@ attribute-list:
   attribute-list ',' attributeₒₚₜ
   attribute '...'
   attribute-list ',' attribute '...'
 ```
 ``` bnf
 attribute:
     attribute-token attribute-argument-clauseₒₚₜ
 ```
 ``` bnf
 attribute-token:
     identifier
     attribute-scoped-token
 ```
@@ -61,20 +74,20 @@ attribute-argument-clause:
     '(' balanced-token-seqₒₚₜ ')'
 ```
 ``` bnf
 balanced-token-seq:
-    balanced-token
-    balanced-token-seq balanced-token
 ```
 ``` bnf
 balanced-token:
     '(' balanced-token-seqₒₚₜ ')'
     '[' balanced-token-seqₒₚₜ ']'
     '{' balanced-token-seqₒₚₜ '}'
- any *token* other than a parenthesis, a bracket, or a brace
 ```
 If an *attribute-specifier* contains an *attribute-using-prefix*, the
 *attribute-list* following that *attribute-using-prefix* shall not
 contain an *attribute-scoped-token* and every *attribute-token* in that
@@ -103,30 +116,34 @@ contain an *attribute-scoped-token* and every *attribute-token* in that
 *balanced-token-seq* will be specified. — *end note*]
 In an *attribute-list*, an ellipsis may appear only if that
 *attribute*’s specification permits it. An *attribute* followed by an
 ellipsis is a pack expansion [[temp.variadic]]. An *attribute-specifier*
-that contains no *attribute*s has no effect. The order in which the
-*attribute-token*s appear in an *attribute-list* is not significant. If
-a keyword [[lex.key]] or an alternative token [[lex.digraph]] that
-satisfies the syntactic requirements of an *identifier* [[lex.name]] is
-contained in an *attribute-token*, it is considered an identifier. No
-name lookup [[basic.lookup]] is performed on any of the identifiers
-contained in an *attribute-token*. The *attribute-token* determines
-additional requirements on the *attribute-argument-clause* (if any).
 Each *attribute-specifier-seq* is said to *appertain* to some entity or
 statement, identified by the syntactic context where it appears
-[[stmt.stmt]], [[dcl.dcl]], [[dcl.decl]]. If an
-*attribute-specifier-seq* that appertains to some entity or statement
-contains an *attribute* or *alignment-specifier* that is not allowed to
-apply to that entity or statement, the program is ill-formed. If an
-*attribute-specifier-seq* appertains to a friend declaration
-[[class.friend]], that declaration shall be a definition.
-[*Note 3*: An *attribute-specifier-seq* cannot appeartain to an
-explicit instantiation [[temp.explicit]]. — *end note*]
 For an *attribute-token* (including an *attribute-scoped-token*) not
 specified in this document, the behavior is *implementation-defined*;
 any such *attribute-token* that is not recognized by the implementation
 is ignored.
@@ -277,17 +294,21 @@ present and shall have the form:
 ```
 The expression is contextually converted to `bool` [[conv.general]]. The
 expression is not evaluated. If the converted expression would evaluate
 to `true` at the point where the assumption appears, the assumption has
-no effect. Otherwise, the behavior is undefined.
 [*Note 1*: The expression is potentially evaluated [[basic.def.odr]].
 The use of assumptions is intended to allow implementations to analyze
 the form of the expression and deduce information used to optimize the
 program. Implementations are not required to deduce any information from
-any particular assumption. — *end note*]
 [*Example 1*:
 ``` cpp
 int divide_by_32(int x) {
@@ -301,84 +322,10 @@ int f(int y) {
 }
 ```
 — *end example*]
-### Carries dependency attribute <a id="dcl.attr.depend">[[dcl.attr.depend]]</a>
-The *attribute-token* `carries_dependency` specifies dependency
-propagation into and out of functions. No *attribute-argument-clause*
-shall be present. The attribute may be applied to a parameter of a
-function or lambda, in which case it specifies that the initialization
-of the parameter carries a dependency to [[intro.multithread]] each
-lvalue-to-rvalue conversion [[conv.lval]] of that object. The attribute
-may also be applied to a function or a lambda call operator, in which
-case it specifies that the return value, if any, carries a dependency to
-the evaluation of the function call expression.
-The first declaration of a function shall specify the
-`carries_dependency` attribute for its *declarator-id* if any
-declaration of the function specifies the `carries_dependency`
-attribute. Furthermore, the first declaration of a function shall
-specify the `carries_dependency` attribute for a parameter if any
-declaration of that function specifies the `carries_dependency`
-attribute for that parameter. If a function or one of its parameters is
-declared with the `carries_dependency` attribute in its first
-declaration in one translation unit and the same function or one of its
-parameters is declared without the `carries_dependency` attribute in its
-first declaration in another translation unit, the program is
-ill-formed, no diagnostic required.
-[*Note 1*: The `carries_dependency` attribute does not change the
-meaning of the program, but might result in generation of more efficient
-code. — *end note*]
-[*Example 1*:
-``` cpp
-/* Translation unit A. */
-struct foo { int* a; int* b; };
-std::atomic<struct foo *> foo_head[10];
-int foo_array[10][10];
-[[carries_dependency]] struct foo* f(int i) {
-  return foo_head[i].load(memory_order::consume);
-}
-int g(int* x, int* y [[carries_dependency]]) {
-  return kill_dependency(foo_array[*x][*y]);
-}
-/* Translation unit B. */
-[[carries_dependency]] struct foo* f(int i);
-int g(int* x, int* y [[carries_dependency]]);
-int c = 3;
-void h(int i) {
-  struct foo* p;
-  p = f(i);
-  do_something_with(g(&c, p->a));
-  do_something_with(g(p->a, &c));
-}
-```
-The `carries_dependency` attribute on function `f` means that the return
-value carries a dependency out of `f`, so that the implementation need
-not constrain ordering upon return from `f`. Implementations of `f` and
-its caller may choose to preserve dependencies instead of emitting
-hardware memory ordering instructions (a.k.a. fences). Function `g`’s
-second parameter has a `carries_dependency` attribute, but its first
-parameter does not. Therefore, function `h`’s first call to `g` carries
-a dependency into `g`, but its second call does not. The implementation
-might need to insert a fence prior to the second call to `g`.
-— *end example*]
 ### Deprecated attribute <a id="dcl.attr.deprecated">[[dcl.attr.deprecated]]</a>
 The *attribute-token* `deprecated` can be used to mark names and
 entities whose use is still allowed, but is discouraged for some reason.
@@ -387,21 +334,20 @@ entities that are deemed obsolescent or unsafe. — *end note*]
 An *attribute-argument-clause* may be present and, if present, it shall
 have the form:
 ``` bnf
-'(' string-literal ')'
 ```
-[*Note 2*: The *string-literal* in the *attribute-argument-clause* can
-be used to explain the rationale for deprecation and/or to suggest a
 replacing entity. — *end note*]
-The attribute may be applied to the declaration of a class, a
-*typedef-name*, a variable, a non-static data member, a function, a
-namespace, an enumeration, an enumerator, a concept, or a template
-specialization.
 An entity declared without the `deprecated` attribute can later be
 redeclared with the attribute and vice-versa.
 [*Note 3*: Thus, an entity initially declared without the attribute can
@@ -416,16 +362,18 @@ the *attribute-argument-clause* or with different
 *Recommended practice:* Implementations should use the `deprecated`
 attribute to produce a diagnostic message in case the program refers to
 a name or entity other than to declare it, after a declaration that
 specifies the attribute. The diagnostic message should include the text
 provided within the *attribute-argument-clause* of any `deprecated`
-attribute applied to the name or entity.
 ### Fallthrough attribute <a id="dcl.attr.fallthrough">[[dcl.attr.fallthrough]]</a>
 The *attribute-token* `fallthrough` may be applied to a null statement
-[[stmt.expr]]; such a statement is a fallthrough statement. No
 *attribute-argument-clause* shall be present. A fallthrough statement
 may only appear within an enclosing `switch` statement [[stmt.switch]].
 The next statement that would be executed after a fallthrough statement
 shall be a labeled statement whose label is a case label or default
 label for the same `switch` statement and, if the fallthrough statement
@@ -435,12 +383,15 @@ iteration statement. The program is ill-formed if there is no such
 statement.
 *Recommended practice:* The use of a fallthrough statement should
 suppress a warning that an implementation might otherwise issue for a
 case or default label that is reachable from another case or default
-label along some path of execution. Implementations should issue a
-warning if a fallthrough statement is not dynamically reachable.
 [*Example 1*:
 ``` cpp
 void f(int n) {
@@ -471,30 +422,76 @@ void f(int n) {
 }
 ```
 — *end example*]
 ### Likelihood attributes <a id="dcl.attr.likelihood">[[dcl.attr.likelihood]]</a>
 The *attribute-token*s `likely` and `unlikely` may be applied to labels
 or statements. No *attribute-argument-clause* shall be present. The
 *attribute-token* `likely` shall not appear in an
 *attribute-specifier-seq* that contains the *attribute-token*
 `unlikely`.
-*Recommended practice:* The use of the `likely` attribute is intended to
-allow implementations to optimize for the case where paths of execution
 including it are arbitrarily more likely than any alternative path of
 execution that does not include such an attribute on a statement or
 label. The use of the `unlikely` attribute is intended to allow
 implementations to optimize for the case where paths of execution
 including it are arbitrarily more unlikely than any alternative path of
 execution that does not include such an attribute on a statement or
-label. A path of execution includes a label if and only if it contains a
-jump to that label.
-[*Note 1*: Excessive usage of either of these attributes is liable to
 result in performance degradation. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -520,41 +517,50 @@ int f(int n) {
 — *end example*]
 ### Maybe unused attribute <a id="dcl.attr.unused">[[dcl.attr.unused]]</a>
-The *attribute-token* `maybe_unused` indicates that a name or entity is
-possibly intentionally unused. No *attribute-argument-clause* shall be
-present.
-The attribute may be applied to the declaration of a class, a
-*typedef-name*, a variable (including a structured binding declaration),
-a non-static data member, a function, an enumeration, or an enumerator.
 A name or entity declared without the `maybe_unused` attribute can later
 be redeclared with the attribute and vice versa. An entity is considered
 marked after the first declaration that marks it.
 *Recommended practice:* For an entity marked `maybe_unused`,
 implementations should not emit a warning that the entity or its
 structured bindings (if any) are used or unused. For a structured
 binding declaration not marked `maybe_unused`, implementations should
 not emit such a warning unless all of its structured bindings are
-unused.
 [*Example 1*:
 ``` cpp
 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                         [[maybe_unused]] bool thing2) {
   [[maybe_unused]] bool b = thing1 && thing2;
   assert(b);
 }
 ```
-Implementations should not warn that `b` is unused, whether or not
-`NDEBUG` is defined.
 — *end example*]
 ### Nodiscard attribute <a id="dcl.attr.nodiscard">[[dcl.attr.nodiscard]]</a>
@@ -562,11 +568,11 @@ The *attribute-token* `nodiscard` may be applied to a function or a
 lambda call operator or to the declaration of a class or enumeration. An
 *attribute-argument-clause* may be present and, if present, shall have
 the form:
 ``` bnf
-'(' string-literal ')'
 ```
 A name or entity declared without the `nodiscard` attribute can later be
 redeclared with the attribute and vice-versa.
@@ -591,20 +597,22 @@ is either
   constructs an object through a constructor declared `nodiscard` in a
   reachable declaration, or that initializes an object of a nodiscard
   type.
 *Recommended practice:* Appearance of a nodiscard call as a
-potentially-evaluated discarded-value expression [[expr.prop]] is
-discouraged unless explicitly cast to `void`. Implementations should
-issue a warning in such cases.
 [*Note 2*: This is typically because discarding the return value of a
 nodiscard call has surprising consequences. — *end note*]
-The *string-literal* in a `nodiscard` *attribute-argument-clause* should
-be used in the message of the warning as the rationale for why the
-result should not be discarded.
 [*Example 1*:
 ``` cpp
 struct [[nodiscard]] my_scopeguard { ... };
@@ -643,19 +651,21 @@ declaration of that function specifies the `noreturn` attribute. If a
 function is declared with the `noreturn` attribute in one translation
 unit and the same function is declared without the `noreturn` attribute
 in another translation unit, the program is ill-formed, no diagnostic
 required.
-If a function `f` is called where `f` was previously declared with the
-`noreturn` attribute and `f` eventually returns, the behavior is
-undefined.
-[*Note 1*: The function may terminate by throwing an
 exception. — *end note*]
 *Recommended practice:* Implementations should issue a warning if a
-function marked `[[noreturn]]` might return.
 [*Example 1*:
 ``` cpp
 [[ noreturn ]] void f() {
@@ -680,10 +690,15 @@ appertain to a non-static data member other than a bit-field.
 [*Note 1*: The non-static data member can share the address of another
 non-static data member or that of a base class, and any padding that
 would normally be inserted at the end of the object can be reused as
 storage for other members. — *end note*]
 [*Example 1*:
 ``` cpp
 template<typename Key, typename Value,
          typename Hash, typename Pred, typename Allocator>
@@ -701,27 +716,76 @@ public:
 Here, `hasher`, `pred`, and `alloc` could have the same address as
 `buckets` if their respective types are all empty.
 — *end example*]
 <!-- Link reference definitions -->
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.namespace]: #basic.namespace
 [basic.namespace.general]: #basic.namespace.general
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.scope]: basic.md#basic.scope.scope
 [basic.start]: basic.md#basic.start
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
@@ -736,10 +800,11 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [class]: class.md#class
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
 [class.conv.ctor]: class.md#class.conv.ctor
 [class.conv.fct]: class.md#class.conv.fct
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
@@ -774,37 +839,43 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rval]: expr.md#conv.rval
 [coroutine.handle]: support.md#coroutine.handle
 [coroutine.handle.resumption]: support.md#coroutine.handle.resumption
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.assume]: #dcl.attr.assume
-[dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.likelihood]: #dcl.attr.likelihood
 [dcl.attr.nodiscard]: #dcl.attr.nodiscard
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.attr.nouniqueaddr]: #dcl.attr.nouniqueaddr
 [dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.constinit]: #dcl.constinit
-[dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.decl.general]: #dcl.decl.general
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.fct.def]: #dcl.fct.def
 [dcl.fct.def.coroutine]: #dcl.fct.def.coroutine
 [dcl.fct.def.default]: #dcl.fct.def.default
 [dcl.fct.def.delete]: #dcl.fct.def.delete
 [dcl.fct.def.general]: #dcl.fct.def.general
 [dcl.fct.default]: #dcl.fct.default
 [dcl.fct.spec]: #dcl.fct.spec
 [dcl.friend]: #dcl.friend
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
@@ -832,53 +903,63 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.decltype]: #dcl.type.decltype
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.general]: #dcl.type.general
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
 [depr.volatile.type]: future.md#depr.volatile.type
 [enum]: #enum
 [enum.udecl]: #enum.udecl
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr.alignof]: expr.md#expr.alignof
-[expr.ass]: expr.md#expr.ass
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.comma]: expr.md#expr.comma
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
 [expr.post.incr]: expr.md#expr.post.incr
 [expr.pre.incr]: expr.md#expr.pre.incr
 [expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
 [expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.prim.this]: expr.md#expr.prim.this
 [expr.prop]: expr.md#expr.prop
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.yield]: expr.md#expr.yield
 [initializer.list.syn]: support.md#initializer.list.syn
 [intro.abstract]: intro.md#intro.abstract
-[intro.compliance]: intro.md#intro.compliance
 [intro.execution]: basic.md#intro.execution
-[intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [lex.string]: lex.md#lex.string
 [module.interface]: module.md#module.interface
 [module.reach]: module.md#module.reach
 [module.unit]: module.md#module.unit
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
@@ -902,21 +983,24 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [special]: class.md#special
 [std.modules]: library.md#std.modules
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.expr]: stmt.md#stmt.expr
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.select]: stmt.md#stmt.select
-[stmt.stmt]: stmt.md#stmt.stmt
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.decls]: temp.md#temp.decls
 [temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.deduct.decl]: temp.md#temp.deduct.decl
@@ -929,10 +1013,12 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [temp.local]: temp.md#temp.local
 [temp.names]: temp.md#temp.names
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
 [term.odr.use]: basic.md#term.odr.use
 [term.padding.bits]: basic.md#term.padding.bits
 [term.scalar.type]: basic.md#term.scalar.type

 ## Attributes <a id="dcl.attr">[[dcl.attr]]</a>
 ### Attribute syntax and semantics <a id="dcl.attr.grammar">[[dcl.attr.grammar]]</a>
+Attributes and annotations specify additional information for various
+source constructs such as types, variables, names, contract assertions,
+blocks, or translation units.
 ``` bnf
 attribute-specifier-seq:
+  attribute-specifier attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 attribute-specifier:
   '[' '[' attribute-using-prefixₒₚₜ attribute-list ']' ']'
+  '[' '[' annotation-list ']' ']'
   alignment-specifier
 ```
 ``` bnf
 alignment-specifier:
   attribute-list ',' attributeₒₚₜ
   attribute '...'
   attribute-list ',' attribute '...'
 ```
+``` bnf
+annotation-list:
+  annotation '...'ₒₚₜ
+  annotation-list ',' annotation '...'ₒₚₜ
+```
 ``` bnf
 attribute:
     attribute-token attribute-argument-clauseₒₚₜ
 ```
+``` bnf
+annotation:
+    '=' constant-expression
+```
 ``` bnf
 attribute-token:
     identifier
     attribute-scoped-token
 ```
     '(' balanced-token-seqₒₚₜ ')'
 ```
 ``` bnf
 balanced-token-seq:
+    balanced-token balanced-token-seqₒₚₜ
 ```
 ``` bnf
 balanced-token:
     '(' balanced-token-seqₒₚₜ ')'
     '[' balanced-token-seqₒₚₜ ']'
     '{' balanced-token-seqₒₚₜ '}'
+ '[:' balanced-token-seqₒₚₜ ':]'
+    any *token* other than '(', ')', '[', ']', '{', '}', '[:', or ':]'
 ```
 If an *attribute-specifier* contains an *attribute-using-prefix*, the
 *attribute-list* following that *attribute-using-prefix* shall not
 contain an *attribute-scoped-token* and every *attribute-token* in that
 *balanced-token-seq* will be specified. — *end note*]
 In an *attribute-list*, an ellipsis may appear only if that
 *attribute*’s specification permits it. An *attribute* followed by an
 ellipsis is a pack expansion [[temp.variadic]]. An *attribute-specifier*
+that contains an *attribute-list* with no *attribute*s has no effect.
+The order in which the *attribute-token*s appear in an *attribute-list*
+is not significant. If a keyword [[lex.key]] or an alternative token
+[[lex.digraph]] that satisfies the syntactic requirements of an
+*identifier* [[lex.name]] is contained in an *attribute-token*, it is
+considered an identifier. No name lookup [[basic.lookup]] is performed
+on any of the identifiers contained in an *attribute-token*. The
+*attribute-token* determines additional requirements on the
+*attribute-argument-clause* (if any).
+An *annotation* followed by an ellipsis is a pack expansion
+[[temp.variadic]].
 Each *attribute-specifier-seq* is said to *appertain* to some entity or
 statement, identified by the syntactic context where it appears
+[[stmt]], [[dcl]], [[dcl.decl]]. If an *attribute-specifier-seq* that
+appertains to some entity or statement contains an *attribute* or
+*alignment-specifier* that is not allowed to apply to that entity or
+statement, the program is ill-formed. If an *attribute-specifier-seq*
+appertains to a friend declaration [[class.friend]], that declaration
+shall be a definition.
+[*Note 3*: An *attribute-specifier-seq* cannot appertain to an explicit
+instantiation [[temp.explicit]]. — *end note*]
 For an *attribute-token* (including an *attribute-scoped-token*) not
 specified in this document, the behavior is *implementation-defined*;
 any such *attribute-token* that is not recognized by the implementation
 is ignored.
 ```
 The expression is contextually converted to `bool` [[conv.general]]. The
 expression is not evaluated. If the converted expression would evaluate
 to `true` at the point where the assumption appears, the assumption has
+no effect. Otherwise, evaluation of the assumption has runtime-undefined
+behavior.
 [*Note 1*: The expression is potentially evaluated [[basic.def.odr]].
 The use of assumptions is intended to allow implementations to analyze
 the form of the expression and deduce information used to optimize the
 program. Implementations are not required to deduce any information from
+any particular assumption. It is expected that the value of a
+*has-attribute-expression* for the `assume` attribute is `0` if an
+implementation does not attempt to deduce any such information from
+assumptions. — *end note*]
 [*Example 1*:
 ``` cpp
 int divide_by_32(int x) {
 }
 ```
 — *end example*]
 ### Deprecated attribute <a id="dcl.attr.deprecated">[[dcl.attr.deprecated]]</a>
 The *attribute-token* `deprecated` can be used to mark names and
 entities whose use is still allowed, but is discouraged for some reason.
 An *attribute-argument-clause* may be present and, if present, it shall
 have the form:
 ``` bnf
+'(' unevaluated-string ')'
 ```
+[*Note 2*: The *unevaluated-string* in the *attribute-argument-clause*
+can be used to explain the rationale for deprecation and/or to suggest a
 replacing entity. — *end note*]
+The attribute may be applied to the declaration of a class, a type
+alias, a variable, a non-static data member, a function, a namespace, an
+enumeration, an enumerator, a concept, or a template specialization.
 An entity declared without the `deprecated` attribute can later be
 redeclared with the attribute and vice-versa.
 [*Note 3*: Thus, an entity initially declared without the attribute can
 *Recommended practice:* Implementations should use the `deprecated`
 attribute to produce a diagnostic message in case the program refers to
 a name or entity other than to declare it, after a declaration that
 specifies the attribute. The diagnostic message should include the text
 provided within the *attribute-argument-clause* of any `deprecated`
+attribute applied to the name or entity. The value of a
+*has-attribute-expression* for the `deprecated` attribute should be `0`
+unless the implementation can issue such diagnostic messages.
 ### Fallthrough attribute <a id="dcl.attr.fallthrough">[[dcl.attr.fallthrough]]</a>
 The *attribute-token* `fallthrough` may be applied to a null statement
+[[stmt.expr]]; such a statement is a *fallthrough statement*. No
 *attribute-argument-clause* shall be present. A fallthrough statement
 may only appear within an enclosing `switch` statement [[stmt.switch]].
 The next statement that would be executed after a fallthrough statement
 shall be a labeled statement whose label is a case label or default
 label for the same `switch` statement and, if the fallthrough statement
 statement.
 *Recommended practice:* The use of a fallthrough statement should
 suppress a warning that an implementation might otherwise issue for a
 case or default label that is reachable from another case or default
+label along some path of execution. The value of a
+*has-attribute-expression* for the `fallthrough` attribute should be `0`
+if the attribute does not cause suppression of such warnings.
+Implementations should issue a warning if a fallthrough statement is not
+dynamically reachable.
 [*Example 1*:
 ``` cpp
 void f(int n) {
 }
 ```
 — *end example*]
+### Indeterminate storage <a id="dcl.attr.indet">[[dcl.attr.indet]]</a>
+The *attribute-token* `indeterminate` may be applied to the definition
+of a block variable with automatic storage duration or to a
+*parameter-declaration* of a function declaration. No
+*attribute-argument-clause* shall be present. The attribute specifies
+that the storage of an object with automatic storage duration is
+initially indeterminate rather than erroneous [[basic.indet]].
+If a function parameter is declared with the `indeterminate` attribute,
+it shall be so declared in the first declaration of its function. If a
+function parameter is declared with the `indeterminate` attribute in the
+first declaration of its function in one translation unit and the same
+function is declared without the `indeterminate` attribute on the same
+parameter in its first declaration in another translation unit, the
+program is ill-formed, no diagnostic required.
+[*Note 1*:
+Reading from an uninitialized variable that is marked
+`[[indeterminate]]` can cause undefined behavior.
+``` cpp
+void f(int);
+void g() {
+  int x [[indeterminate]], y;
+  f(y);                 // erroneous behavior[basic.indet]
+  f(x);                 // undefined behavior
+}
+struct T {
+  T() {}
+  int x;
+};
+int h(T t [[indeterminate]]) {
+  f(t.x);               // undefined behavior when called below
+  return 0;
+}
+int _ = h(T());
+```
+— *end note*]
 ### Likelihood attributes <a id="dcl.attr.likelihood">[[dcl.attr.likelihood]]</a>
 The *attribute-token*s `likely` and `unlikely` may be applied to labels
 or statements. No *attribute-argument-clause* shall be present. The
 *attribute-token* `likely` shall not appear in an
 *attribute-specifier-seq* that contains the *attribute-token*
 `unlikely`.
+[*Note 1*: The use of the `likely` attribute is intended to allow
+implementations to optimize for the case where paths of execution
 including it are arbitrarily more likely than any alternative path of
 execution that does not include such an attribute on a statement or
 label. The use of the `unlikely` attribute is intended to allow
 implementations to optimize for the case where paths of execution
 including it are arbitrarily more unlikely than any alternative path of
 execution that does not include such an attribute on a statement or
+label. It is expected that the value of a *has-attribute-expression* for
+the `likely` and `unlikely` attributes is `0` if the implementation does
+not attempt to use these attributes for such optimizations. A path of
+execution includes a label if and only if it contains a jump to that
+label. — *end note*]
+[*Note 2*: Excessive usage of either of these attributes is liable to
 result in performance degradation. — *end note*]
 [*Example 1*:
 ``` cpp
 — *end example*]
 ### Maybe unused attribute <a id="dcl.attr.unused">[[dcl.attr.unused]]</a>
+The *attribute-token* `maybe_unused` indicates that a name, label, or
+entity is possibly intentionally unused. No *attribute-argument-clause*
+shall be present.
+The attribute may be applied to the declaration of a class, type alias,
+variable (including a structured binding declaration), structured
+binding, result binding [[dcl.contract.res]], non-static data member,
+function, enumeration, or enumerator, or to an *identifier* label
+[[stmt.label]].
 A name or entity declared without the `maybe_unused` attribute can later
 be redeclared with the attribute and vice versa. An entity is considered
 marked after the first declaration that marks it.
 *Recommended practice:* For an entity marked `maybe_unused`,
 implementations should not emit a warning that the entity or its
 structured bindings (if any) are used or unused. For a structured
 binding declaration not marked `maybe_unused`, implementations should
 not emit such a warning unless all of its structured bindings are
+unused. For a label to which `maybe_unused` is applied, implementations
+should not emit a warning that the label is used or unused. The value of
+a *has-attribute-expression* for the `maybe_unused` attribute should be
+`0` if the attribute does not cause suppression of such warnings.
 [*Example 1*:
 ``` cpp
 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                         [[maybe_unused]] bool thing2) {
   [[maybe_unused]] bool b = thing1 && thing2;
   assert(b);
+#ifdef NDEBUG
+  goto x;
+#endif
+  [[maybe_unused]] x:
 }
 ```
+Implementations should not warn that `b` or `x` is unused, whether or
+not `NDEBUG` is defined.
 — *end example*]
 ### Nodiscard attribute <a id="dcl.attr.nodiscard">[[dcl.attr.nodiscard]]</a>
 lambda call operator or to the declaration of a class or enumeration. An
 *attribute-argument-clause* may be present and, if present, shall have
 the form:
 ``` bnf
+'(' unevaluated-string ')'
 ```
 A name or entity declared without the `nodiscard` attribute can later be
 redeclared with the attribute and vice-versa.
   constructs an object through a constructor declared `nodiscard` in a
   reachable declaration, or that initializes an object of a nodiscard
   type.
 *Recommended practice:* Appearance of a nodiscard call as a
+potentially-evaluated discarded-value expression [[expr.prop]] of
+non-void type is discouraged unless explicitly cast to `void`.
+Implementations should issue a warning in such cases. The value of a
+*has-attribute-expression* for the `nodiscard` attribute should be `0`
+unless the implementation can issue such warnings.
 [*Note 2*: This is typically because discarding the return value of a
 nodiscard call has surprising consequences. — *end note*]
+The *unevaluated-string* in a `nodiscard` *attribute-argument-clause*
+should be used in the message of the warning as the rationale for why
+the result should not be discarded.
 [*Example 1*:
 ``` cpp
 struct [[nodiscard]] my_scopeguard { ... };
 function is declared with the `noreturn` attribute in one translation
 unit and the same function is declared without the `noreturn` attribute
 in another translation unit, the program is ill-formed, no diagnostic
 required.
+If a function `f` is invoked where `f` was previously declared with the
+`noreturn` attribute and that invocation eventually returns, the
+behavior is runtime-undefined.
+[*Note 1*: The function can terminate by throwing an
 exception. — *end note*]
 *Recommended practice:* Implementations should issue a warning if a
+function marked `[[noreturn]]` might return. The value of a
+*has-attribute-expression* for the `noreturn` attribute should be `0`
+unless the implementation can issue such warnings.
 [*Example 1*:
 ``` cpp
 [[ noreturn ]] void f() {
 [*Note 1*: The non-static data member can share the address of another
 non-static data member or that of a base class, and any padding that
 would normally be inserted at the end of the object can be reused as
 storage for other members. — *end note*]
+*Recommended practice:* The value of a *has-attribute-expression* for
+the `no_unique_address` attribute should be `0` for a given
+implementation unless this attribute can cause a potentially-overlapping
+subobject to have zero size.
 [*Example 1*:
 ``` cpp
 template<typename Key, typename Value,
          typename Hash, typename Pred, typename Allocator>
 Here, `hasher`, `pred`, and `alloc` could have the same address as
 `buckets` if their respective types are all empty.
 — *end example*]
+### Annotations <a id="dcl.attr.annotation">[[dcl.attr.annotation]]</a>
+An annotation may be applied to any declaration of a type, type alias,
+variable, function, namespace, enumerator, *base-specifier*, or
+non-static data member.
+Let E be the expression
+`std::meta::reflect_constant(constant-expression)`. E shall be a
+constant expression; the result of E is the *underlying constant* of the
+annotation.
+Each *annotation* produces a unique annotation.
+Substituting into an *annotation* is not in the immediate context.
+[*Example 1*:
+``` cpp
+[[=1]] void f();
+[[=2, =3, =2]] void g();
+void g [[=4, =2]] ();
+```
+`f` has one annotation and `g` has five annotations. These can be
+queried with metafunctions such as `std::{}meta::{}annotations_of`
+[[meta.reflection.annotation]].
+— *end example*]
+[*Example 2*:
+``` cpp
+template<class T>
+  [[=T::type()]] void f(T t);
+void f(int);
+void g() {
+  f(0);         // OK
+  f('0');       // error, substituting into the annotation results in an invalid expression
+}
+```
+— *end example*]
 <!-- Link reference definitions -->
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
+[basic.contract.general]: basic.md#basic.contract.general
 [basic.def]: basic.md#basic.def
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
+[basic.indet]: basic.md#basic.indet
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
+[basic.lval]: expr.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.namespace.general]: #basic.namespace.general
+[basic.pre]: basic.md#basic.pre
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.scope]: basic.md#basic.scope.scope
 [basic.start]: basic.md#basic.start
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
 [class]: class.md#class
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
+[class.compare.default]: class.md#class.compare.default
 [class.conv.ctor]: class.md#class.conv.ctor
 [class.conv.fct]: class.md#class.conv.fct
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rval]: expr.md#conv.rval
 [coroutine.handle]: support.md#coroutine.handle
 [coroutine.handle.resumption]: support.md#coroutine.handle.resumption
+[csetjmp.syn]: support.md#csetjmp.syn
+[dcl]: #dcl
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
+[dcl.attr.annotation]: #dcl.attr.annotation
 [dcl.attr.assume]: #dcl.attr.assume
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
+[dcl.attr.indet]: #dcl.attr.indet
 [dcl.attr.likelihood]: #dcl.attr.likelihood
 [dcl.attr.nodiscard]: #dcl.attr.nodiscard
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.attr.nouniqueaddr]: #dcl.attr.nouniqueaddr
 [dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.constinit]: #dcl.constinit
+[dcl.contract]: #dcl.contract
+[dcl.contract.func]: #dcl.contract.func
+[dcl.contract.res]: #dcl.contract.res
 [dcl.decl]: #dcl.decl
 [dcl.decl.general]: #dcl.decl.general
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.fct.def]: #dcl.fct.def
 [dcl.fct.def.coroutine]: #dcl.fct.def.coroutine
 [dcl.fct.def.default]: #dcl.fct.def.default
 [dcl.fct.def.delete]: #dcl.fct.def.delete
 [dcl.fct.def.general]: #dcl.fct.def.general
+[dcl.fct.def.replace]: #dcl.fct.def.replace
 [dcl.fct.default]: #dcl.fct.default
 [dcl.fct.spec]: #dcl.fct.spec
 [dcl.friend]: #dcl.friend
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.decltype]: #dcl.type.decltype
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.general]: #dcl.type.general
+[dcl.type.pack.index]: #dcl.type.pack.index
 [dcl.type.simple]: #dcl.type.simple
+[dcl.type.splice]: #dcl.type.splice
 [dcl.typedef]: #dcl.typedef
+[depr.ellipsis.comma]: future.md#depr.ellipsis.comma
 [depr.volatile.type]: future.md#depr.volatile.type
 [enum]: #enum
 [enum.udecl]: #enum.udecl
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr.alignof]: expr.md#expr.alignof
+[expr.assign]: expr.md#expr.assign
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.comma]: expr.md#expr.comma
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
 [expr.post.incr]: expr.md#expr.post.incr
 [expr.pre.incr]: expr.md#expr.pre.incr
+[expr.prim.id]: expr.md#expr.prim.id
 [expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
 [expr.prim.lambda]: expr.md#expr.prim.lambda
+[expr.prim.lambda.closure]: expr.md#expr.prim.lambda.closure
 [expr.prim.this]: expr.md#expr.prim.this
 [expr.prop]: expr.md#expr.prop
 [expr.ref]: expr.md#expr.ref
+[expr.reflect]: expr.md#expr.reflect
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
+[expr.throw]: expr.md#expr.throw
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.yield]: expr.md#expr.yield
 [initializer.list.syn]: support.md#initializer.list.syn
 [intro.abstract]: intro.md#intro.abstract
 [intro.execution]: basic.md#intro.execution
 [intro.object]: basic.md#intro.object
+[intro.races]: basic.md#intro.races
+[lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
+[lex.phases]: lex.md#lex.phases
 [lex.string]: lex.md#lex.string
+[lex.string.uneval]: lex.md#lex.string.uneval
+[meta.reflection.annotation]: meta.md#meta.reflection.annotation
 [module.interface]: module.md#module.interface
 [module.reach]: module.md#module.reach
 [module.unit]: module.md#module.unit
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [special]: class.md#special
 [std.modules]: library.md#std.modules
+[stmt]: stmt.md#stmt
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.expr]: stmt.md#stmt.expr
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
+[stmt.label]: stmt.md#stmt.label
+[stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.select]: stmt.md#stmt.select
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
+[temp.arg.nontype]: temp.md#temp.arg.nontype
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.decls]: temp.md#temp.decls
 [temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.deduct.decl]: temp.md#temp.deduct.decl
 [temp.local]: temp.md#temp.local
 [temp.names]: temp.md#temp.names
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
+[temp.res.general]: temp.md#temp.res.general
+[temp.spec.general]: temp.md#temp.spec.general
 [temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
 [term.odr.use]: basic.md#term.odr.use
 [term.padding.bits]: basic.md#term.padding.bits
 [term.scalar.type]: basic.md#term.scalar.type

Diff to HTML by rtfpessoa