[expr.const] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp78ub49ga/{from.md → to.md} +530 -166

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

@@ -3,31 +3,130 @@
 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
 different semantics depending on whether or not an expression satisfies
 these requirements. Expressions that satisfy these requirements,
 assuming that copy elision [[class.copy.elision]] is not performed, are
-called *constant expressions*.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
-A variable or temporary object `o` is *constant-initialized* if
-- either it has an initializer or its default-initialization results in
-  some initialization being performed, and
 - the full-expression of its initialization is a constant expression
-  when interpreted as a *constant-expression*, except that if `o` is an
- object, that full-expression may also invoke constexpr constructors
- for `o` and its subobjects even if those objects are of non-literal
- class types. \[*Note 2*: Such a class can have a non-trivial
- destructor. Within this evaluation, `std::is_constant_evaluated()`
- [[meta.const.eval]] returns `true`. — *end note*]
 A variable is *potentially-constant* if it is constexpr or it has
 reference or non-volatile const-qualified integral or enumeration type.
 A constant-initialized potentially-constant variable V is *usable in
@@ -36,54 +135,80 @@ reachable from P and
 - V is constexpr,
 - V is not initialized to a TU-local value, or
 - P is in the same translation unit as D.
-An object or reference is *usable in constant expressions* if it is
-- a variable that is usable in constant expressions, or
-- a template parameter object [[temp.param]], or
-- a string literal object [[lex.string]], or
 - a temporary object of non-volatile const-qualified literal type whose
   lifetime is extended [[class.temporary]] to that of a variable that is
-  usable in constant expressions, or
-- a non-mutable subobject or reference member of any of the above.
 An expression E is a *core constant expression* unless the evaluation of
 E, following the rules of the abstract machine [[intro.execution]],
 would evaluate one of the following:
 - `this` [[expr.prim.this]], except
   - in a constexpr function [[dcl.constexpr]] that is being evaluated as
     part of E or
   - when appearing as the *postfix-expression* of an implicit or
     explicit class member access expression [[expr.ref]];
-- a control flow that passes through a declaration of a variable with
- static [[basic.stc.static]] or thread [[basic.stc.thread]] storage
-  duration, unless that variable is usable in constant expressions;
- \[*Example 1*:
   ``` cpp
   constexpr char test() {
     static const int x = 5;
     static constexpr char c[] = "Hello World";
     return *(c + x);
   }
   static_assert(' ' == test());
   ```
   — *end example*]
-- an invocation of a non-constexpr function;[^32]
 - an invocation of an undefined constexpr function;
 - an invocation of an instantiated constexpr function that is not
   constexpr-suitable;
 - an invocation of a virtual function [[class.virtual]] for an object
   whose dynamic type is constexpr-unknown;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
-- an operation that would have undefined behavior as specified in
-  [[intro]] through [[cpp]], excluding [[dcl.attr.assume]];[^33]
 - an lvalue-to-rvalue conversion [[conv.lval]] unless it is applied to
   - a non-volatile glvalue that refers to an object that is usable in
     constant expressions, or
   - a non-volatile glvalue of literal type that refers to a non-volatile
     object whose lifetime began within the evaluation of E;
 - an lvalue-to-rvalue conversion that is applied to a glvalue that
@@ -96,11 +221,11 @@ would evaluate one of the following:
   evaluation of E;
 - in a *lambda-expression*, a reference to `this` or to a variable with
   automatic storage duration defined outside that *lambda-expression*,
   where the reference would be an odr-use
   [[term.odr.use]], [[expr.prim.lambda]];
-  \[*Example 2*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
@@ -108,17 +233,17 @@ would evaluate one of the following:
     };
   }
   ```
   — *end example*]
-  \[*Note 3*:
   If the odr-use occurs in an invocation of a function call operator of
   a closure type, it no longer refers to `this` or to an enclosing
-  automatic variable due to the transformation
   [[expr.prim.lambda.capture]] of the *id-expression* into an access of
   the corresponding data member.
-  \[*Example 3*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
@@ -127,61 +252,82 @@ would evaluate one of the following:
   static_assert(bind(monad(2))(monad)() == monad(2)());
   ```
   — *end example*]
   — *end note*]
-- a conversion from type cv `void*` to a pointer-to-object type;
 - a `reinterpret_cast` [[expr.reinterpret.cast]];
 - a modification of an object
-  [[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]] unless it is
   applied to a non-volatile lvalue of literal type that refers to a
   non-volatile object whose lifetime began within the evaluation of E;
 - an invocation of a destructor [[class.dtor]] or a function call whose
   *postfix-expression* names a pseudo-destructor [[expr.call]], in
   either case for an object whose lifetime did not begin within the
   evaluation of E;
-- a *new-expression* [[expr.new]], unless the selected allocation
-  function is a replaceable global allocation function
- [[new.delete.single]], [[new.delete.array]] and the allocated storage
- is deallocated within the evaluation of E;
 - a *delete-expression* [[expr.delete]], unless it deallocates a region
   of storage allocated within the evaluation of E;
 - a call to an instance of `std::allocator<T>::allocate`
   [[allocator.members]], unless the allocated storage is deallocated
   within the evaluation of E;
 - a call to an instance of `std::allocator<T>::deallocate`
   [[allocator.members]], unless it deallocates a region of storage
   allocated within the evaluation of E;
 - an *await-expression* [[expr.await]];
 - a *yield-expression* [[expr.yield]];
 - a three-way comparison [[expr.spaceship]], relational [[expr.rel]], or
   equality [[expr.eq]] operator where the result is unspecified;
-- a *throw-expression* [[expr.throw]];
 - a `dynamic_cast` [[expr.dynamic.cast]] or `typeid` [[expr.typeid]]
   expression on a glvalue that refers to an object whose dynamic type is
-  constexpr-unknown or that would throw an exception;
 - an *asm-declaration* [[dcl.asm]];
 - an invocation of the `va_arg` macro [[cstdarg.syn]];
 - a non-constant library call [[defns.nonconst.libcall]]; or
-- a `goto` statement [[stmt.goto]].
 It is unspecified whether E is a core constant expression if E satisfies
 the constraints of a core constant expression, but evaluation of E would
 evaluate
 - an operation that has undefined behavior as specified in [[library]]
-  through [[thread]],
-- an invocation of the `va_start` macro [[cstdarg.syn]], or
-- a statement with an assumption [[dcl.attr.assume]] whose converted
-  *conditional-expression*, if evaluated where the assumption appears,
-  would not disqualify E from being a core constant expression and would
-  not evaluate to `true`. \[*Note 4*: E is not disqualified from being a
-  core constant expression if the hypothetical evaluation of the
-  converted *conditional-expression* would disqualify E from being a
-  core constant expression. — *end note*]
-[*Example 4*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
@@ -222,38 +368,70 @@ constexpr int y = h(1);             // OK, initializes y with the value 2
 — *end example*]
 For the purposes of determining whether an expression E is a core
 constant expression, the evaluation of the body of a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
-literal type, is ignored. Similarly, the evaluation of the body of
-`std::construct_at` or `std::ranges::construct_at` is considered to
-include only the underlying constructor call if the first argument (of
-type `T*`) points to storage allocated with `std::allocator<T>` or to an
-object whose lifetime began within the evaluation of E.
 For the purposes of determining whether E is a core constant expression,
 the evaluation of a call to a trivial copy/move constructor or copy/move
 assignment operator of a union is considered to copy/move the active
 member of the union, if any.
-[*Note 5*: The copy/move of the active member is
 trivial. — *end note*]
 During the evaluation of an expression E as a core constant expression,
-all *id-expression*s and uses of `*this` that refer to an object or
-reference whose lifetime did not begin with the evaluation of E are
-treated as referring to a specific instance of that object or reference
-whose lifetime and that of all subobjects (including all union members)
-includes the entire constant evaluation. For such an object that is not
-usable in constant expressions, the dynamic type of the object is
-*constexpr-unknown*. For such a reference that is not usable in constant
-expressions, the reference is treated as binding to an unspecified
-object of the referenced type whose lifetime and that of all subobjects
-includes the entire constant evaluation and whose dynamic type is
-constexpr-unknown.
-[*Example 5*:
 ``` cpp
 template <typename T, size_t N>
 constexpr size_t array_size(T (&)[N]) {
   return N;
@@ -305,36 +483,36 @@ constexpr auto& sandeno   = typeid(dc);         // OK, can only be typeid(Swim)
 constexpr auto& gallagher = typeid(trident);    // error: constexpr-unknown dynamic type
 ```
 — *end example*]
-An object `a` is said to have *constant destruction* if:
 - it is not of class type nor (possibly multidimensional) array thereof,
   or
 - it is of class type or (possibly multidimensional) array thereof, that
-  class type has a constexpr destructor, and for a hypothetical
-  expression E whose only effect is to destroy `a`, E would be a core
-  constant expression if the lifetime of `a` and its non-mutable
-  subobjects (but not its mutable subobjects) were considered to start
-  within E.
 An *integral constant expression* is an expression of integral or
 unscoped enumeration type, implicitly converted to a prvalue, where the
 converted expression is a core constant expression.
-[*Note 6*: Such expressions can be used as bit-field lengths
 [[class.bit]], as enumerator initializers if the underlying type is not
 fixed [[dcl.enum]], and as alignments [[dcl.align]]. — *end note*]
 If an expression of literal class type is used in a context where an
 integral constant expression is required, then that expression is
 contextually implicitly converted [[conv]] to an integral or unscoped
 enumeration type and the selected conversion function shall be
 `constexpr`.
-[*Example 6*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
@@ -359,82 +537,110 @@ constant expression and the implicit conversion sequence contains only
 - function-to-pointer conversions [[conv.func]],
 - qualification conversions [[conv.qual]],
 - integral promotions [[conv.prom]],
 - integral conversions [[conv.integral]] other than narrowing
   conversions [[dcl.init.list]],
 - null pointer conversions [[conv.ptr]] from `std::nullptr_t`,
 - null member pointer conversions [[conv.mem]] from `std::nullptr_t`,
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
-[*Note 7*: Such expressions can be used in `new` expressions
 [[expr.new]], as case expressions [[stmt.switch]], as enumerator
 initializers if the underlying type is fixed [[dcl.enum]], as array
-bounds [[dcl.array]], and as non-type template arguments
-[[temp.arg]]. — *end note*]
 A *contextually converted constant expression of type `bool`* is an
 expression, contextually converted to `bool` [[conv]], where the
 converted expression is a constant expression and the conversion
 sequence contains only the conversions above.
-A *constant expression* is either a glvalue core constant expression
-that refers to an entity that is a permitted result of a constant
-expression (as defined below), or a prvalue core constant expression
-whose value satisfies the following constraints:
-- if the value is an object of class type, each non-static data member
- of reference type refers to an entity that is a permitted result of a
- constant expression,
-- if the value is an object of scalar type, it does not have an
-  indeterminate value [[basic.indet]],
-- if the value is of pointer type, it contains the address of an object
-  with static storage duration, the address past the end of such an
-  object [[expr.add]], the address of a non-immediate function, or a
-  null pointer value,
-- if the value is of pointer-to-member-function type, it does not
-  designate an immediate function, and
-- if the value is an object of class or array type, each subobject
-  satisfies these constraints for the value.
-An entity is a *permitted result of a constant expression* if it is an
-object with static storage duration that either is not a temporary
-object or is a temporary object whose value satisfies the above
-constraints, or if it is a non-immediate function.
-[*Note 8*: A glvalue core constant expression that either refers to or
 points to an unspecified object is not a constant
 expression. — *end note*]
-[*Example 7*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
 constexpr int r = h();                          // OK
 constexpr auto e = g();                         // error: a pointer to an immediate function is
                                                 // not a permitted result of a constant expression
 ```
 — *end example*]
 *Recommended practice:* Implementations should provide consistent
 results of floating-point evaluations, irrespective of whether the
 evaluation is performed during translation or during program execution.
-[*Note 9*:
 Since this document imposes no restrictions on the accuracy of
 floating-point operations, it is unspecified whether the evaluation of a
 floating-point expression during translation yields the same result as
 the evaluation of the same expression (or the same operations on the
 same values) during program execution.
-[*Example 8*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
@@ -463,17 +669,18 @@ potentially-evaluated explicit or implicit invocation of an immediate
 function and is not in an immediate function context. An aggregate
 initialization is an immediate invocation if it evaluates a default
 member initializer that has a subexpression that is an
 immediate-escalating expression.
-An expression or conversion is *immediate-escalating* if it is not
-initially in an immediate function context and it is either
-- a potentially-evaluated *id-expression* that denotes an immediate
- function that is not a subexpression of an immediate invocation, or
-- an immediate invocation that is not a constant expression and is not a
-  subexpression of an immediate invocation.
 An *immediate-escalating* function is
 - the call operator of a lambda that is not declared with the
   `consteval` specifier,
@@ -483,18 +690,22 @@ An *immediate-escalating* function is
   defined with the `constexpr` specifier.
 An immediate-escalating expression shall appear only in an
 immediate-escalating function.
-An *immediate function* is a function or constructor that is
 - declared with the `consteval` specifier, or
-- an immediate-escalating function `F` whose function body contains an
- immediate-escalating expression `E` such that `E`’s innermost
- enclosing non-block scope is `F`’s function parameter scope.
-[*Example 9*:
 ``` cpp
 consteval int id(int i) { return i; }
 constexpr char id(char c) { return c; }
@@ -524,16 +735,17 @@ static_assert(is_not(5, is_even));      // OK
 int x = 0;
 template<class T>
 constexpr T h(T t = id(x)) {    // h<int> is not an immediate function
     return t;
 }
 template<class T>
-constexpr T hh() {              // hh<int> is an immediate function
-  return h<T>();
 }
 int i = hh<int>();              // error: hh<int>() is an immediate-escalating expression
                                 // outside of an immediate-escalating function
@@ -544,10 +756,19 @@ struct A {
 template<class T>
 constexpr int k(int) {          // k<int> is not an immediate function because A(42) is a
   return A(42).y;               // constant expression and thus not immediate-escalating
 }
 ```
 — *end example*]
 An expression or conversion is *manifestly constant-evaluated* if it is:
@@ -556,12 +777,12 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
 - the condition of a constexpr if statement [[stmt.if]], or
 - an immediate invocation, or
 - the result of substitution into an atomic constraint expression to
   determine whether it is satisfied [[temp.constr.atomic]], or
 - the initializer of a variable that is usable in constant expressions
-  or has constant initialization [[basic.start.static]].[^34]
-  \[*Example 10*:
   ``` cpp
   template<bool> struct X {};
   X<std::is_constant_evaluated()> x;                      // type X<true>
   int y;
   const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
@@ -580,22 +801,140 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
-[*Note 10*: A manifestly constant-evaluated expression is evaluated
-even in an unevaluated operand
-[[term.unevaluated.operand]]. — *end note*]
 An expression or conversion is *potentially constant evaluated* if it
 is:
 - a manifestly constant-evaluated expression,
 - a potentially-evaluated expression [[basic.def.odr]],
-- an immediate subexpression of a *braced-init-list*,[^35]
 - an expression of the form `&` *cast-expression* that occurs within a
-  templated entity,[^36] or
 - a potentially-evaluated subexpression [[intro.execution]] of one of
   the above.
 A function or variable is *needed for constant evaluation* if it is:
@@ -603,42 +942,51 @@ A function or variable is *needed for constant evaluation* if it is:
   that is potentially constant evaluated, or
 - a potentially-constant variable named by a potentially constant
   evaluated expression.
 <!-- Link reference definitions -->
 [allocator.members]: mem.md#allocator.members
 [bad.alloc]: support.md#bad.alloc
 [bad.cast]: support.md#bad.cast
 [bad.typeid]: support.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
 [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.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
 [basic.pre]: basic.md#basic.pre
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.scope.lambda]: basic.md#basic.scope.lambda
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [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.cdtor]: class.md#class.cdtor
 [class.conv]: class.md#class.conv
 [class.conv.fct]: class.md#class.conv.fct
@@ -649,14 +997,15 @@ A function or variable is *needed for constant evaluation* if it is:
 [class.derived]: class.md#class.derived
 [class.dtor]: class.md#class.dtor
 [class.free]: class.md#class.free
 [class.friend]: class.md#class.friend
 [class.mem]: class.md#class.mem
 [class.member.lookup]: basic.md#class.member.lookup
-[class.mfct]: class.md#class.mfct
 [class.mfct.non.static]: class.md#class.mfct.non.static
 [class.mi]: class.md#class.mi
 [class.prop]: class.md#class.prop
 [class.spaceship]: class.md#class.spaceship
 [class.static.mfct]: class.md#class.static.mfct
 [class.temporary]: basic.md#class.temporary
 [class.union]: class.md#class.union
@@ -679,62 +1028,67 @@ A function or variable is *needed for constant evaluation* if it is:
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [conv.qual]: #conv.qual
 [conv.rank]: basic.md#conv.rank
 [conv.rval]: #conv.rval
-[cpp]: cpp.md#cpp
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.asm]: dcl.md#dcl.asm
-[dcl.attr.assume]: dcl.md#dcl.attr.assume
 [dcl.constexpr]: dcl.md#dcl.constexpr
-[dcl.dcl]: dcl.md#dcl.dcl
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.init.string]: dcl.md#dcl.init.string
 [dcl.link]: dcl.md#dcl.link
 [dcl.mptr]: dcl.md#dcl.mptr
 [dcl.name]: dcl.md#dcl.name
 [dcl.ptr]: dcl.md#dcl.ptr
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.auto.deduct]: dcl.md#dcl.type.auto.deduct
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.decltype]: dcl.md#dcl.type.decltype
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
-[depr.arith.conv.enum]: future.md#depr.arith.conv.enum
-[depr.array.comp]: future.md#depr.array.comp
 [depr.capture.this]: future.md#depr.capture.this
 [depr.volatile.type]: future.md#depr.volatile.type
 [except]: except.md#except
 [except.handle]: except.md#except.handle
 [except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
 [expr.arith.conv]: #expr.arith.conv
-[expr.ass]: #expr.ass
 [expr.await]: #expr.await
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
@@ -757,30 +1111,34 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.post.incr]: #expr.post.incr
 [expr.pre]: #expr.pre
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
 [expr.prim.id]: #expr.prim.id
 [expr.prim.id.dtor]: #expr.prim.id.dtor
 [expr.prim.id.general]: #expr.prim.id.general
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.lambda.general]: #expr.prim.lambda.general
 [expr.prim.literal]: #expr.prim.literal
 [expr.prim.paren]: #expr.prim.paren
 [expr.prim.req]: #expr.prim.req
 [expr.prim.req.compound]: #expr.prim.req.compound
 [expr.prim.req.general]: #expr.prim.req.general
 [expr.prim.req.nested]: #expr.prim.req.nested
 [expr.prim.req.simple]: #expr.prim.req.simple
 [expr.prim.req.type]: #expr.prim.req.type
 [expr.prim.this]: #expr.prim.this
 [expr.prop]: #expr.prop
 [expr.ref]: #expr.ref
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
 [expr.spaceship]: #expr.spaceship
@@ -803,67 +1161,81 @@ A function or variable is *needed for constant evaluation* if it is:
 [intro.memory]: basic.md#intro.memory
 [intro.object]: basic.md#intro.object
 [lex.ext]: lex.md#lex.ext
 [lex.icon]: lex.md#lex.icon
 [lex.literal]: lex.md#lex.literal
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
 [meta.const.eval]: meta.md#meta.const.eval
 [namespace.udecl]: dcl.md#namespace.udecl
 [new.badlength]: support.md#new.badlength
 [new.delete.array]: support.md#new.delete.array
 [new.delete.placement]: support.md#new.delete.placement
 [new.delete.single]: support.md#new.delete.single
 [over]: over.md#over
-[over.ass]: over.md#over.ass
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.call.func]: over.md#over.call.func
 [over.ics.user]: over.md#over.ics.user
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [over.sub]: over.md#over.sub
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [std.modules]: library.md#std.modules
 [stmt.goto]: stmt.md#stmt.goto
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
 [support.types.layout]: support.md#support.types.layout
 [temp.arg]: temp.md#temp.arg
 [temp.concept]: temp.md#temp.concept
 [temp.constr.atomic]: temp.md#temp.constr.atomic
 [temp.constr.constr]: temp.md#temp.constr.constr
 [temp.constr.decl]: temp.md#temp.constr.decl
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.over.link]: temp.md#temp.over.link
 [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.incomplete.type]: basic.md#term.incomplete.type
 [term.object.representation]: basic.md#term.object.representation
 [term.odr.use]: basic.md#term.odr.use
 [term.unevaluated.operand]: #term.unevaluated.operand
-[thread]: thread.md#thread
 [type.info]: support.md#type.info
 [typeinfo.syn]: support.md#typeinfo.syn
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
@@ -871,23 +1243,22 @@ A function or variable is *needed for constant evaluation* if it is:
 [^2]: Overloaded operators are never assumed to be associative or
     commutative.
 [^3]: The cast and assignment operators must still perform their
     specific conversions as described in  [[expr.type.conv]],
-    [[expr.cast]], [[expr.static.cast]] and  [[expr.ass]].
 [^4]: The intent of this list is to specify those circumstances in which
     an object can or cannot be aliased.
 [^5]: For historical reasons, this conversion is called the
     “lvalue-to-rvalue” conversion, even though that name does not
     accurately reflect the taxonomy of expressions described in
     [[basic.lval]].
 [^6]: In C++ class and array prvalues can have cv-qualified types. This
-    differs from ISO C, in which non-lvalues never have cv-qualified
-    types.
 [^7]: This conversion never applies to non-static member functions
     because an lvalue that refers to a non-static member function cannot
     be obtained.
@@ -903,99 +1274,92 @@ A function or variable is *needed for constant evaluation* if it is:
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
     `char32_t`, `wchar_t`, or of enumeration type are converted to some
     integral type.
-[^10]: This also applies when the object expression is an implicit
-    `(*this)` [[class.mfct.non.static]].
-[^11]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
 [^12]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
-[^13]: Note that `(*(E1))` is an lvalue.
-[^14]: The most derived object [[intro.object]] pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
-[^15]: The recommended name for such a class is `extended_type_info`.
-[^16]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
-    `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
-[^17]: The types can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^18]: `T1` and `T2` can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^19]: This is sometimes referred to as a type pun when the result
     refers to the same object as the source glvalue.
-[^20]: `const_cast` is not limited to conversions that cast away a
     const-qualifier.
-[^21]: `sizeof``(``bool``)` is not required to be `1`.
-[^22]: The actual size of a potentially-overlapping subobject can be
     less than the result of applying `sizeof` to the subobject, due to
     virtual base classes and less strict padding requirements on
     potentially-overlapping subobjects.
-[^23]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
-[^24]: This can include evaluating a *new-initializer* and/or calling a
     constructor.
-[^25]: A *lambda-expression* with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the
     *lambda-expression* is enclosed in parentheses.
-[^26]: This implies that an object cannot be deleted using a pointer of
-    type `void*` because `void` is not an object type.
-[^27]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
-[^28]: This is often called truncation towards zero.
-[^29]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
-[^30]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
-[^31]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose.
-[^32]: Overload resolution [[over.match]] is applied as usual.
-[^33]: This includes, for example, signed integer overflow [[expr.pre]],
     certain pointer arithmetic [[expr.add]], division by zero
     [[expr.mul]], or certain shift operations [[expr.shift]].
-[^34]: Testing this condition can involve a trial evaluation of its
-    initializer as described above.
-[^35]: In some cases, constant evaluation is needed to determine whether
     a narrowing conversion is performed [[dcl.init.list]].
-[^36]: In some cases, constant evaluation is needed to determine whether
     such an expression is value-dependent [[temp.dep.constexpr]].

 Certain contexts require expressions that satisfy additional
 requirements as detailed in this subclause; other contexts have
 different semantics depending on whether or not an expression satisfies
 these requirements. Expressions that satisfy these requirements,
 assuming that copy elision [[class.copy.elision]] is not performed, are
+called constant expressions.
 [*Note 1*: Constant expressions can be evaluated during
 translation. — *end note*]
 ``` bnf
 constant-expression:
     conditional-expression
 ```
+The *constituent values* of an object o are
+- if o has scalar type, the value of o;
+- otherwise, the constituent values of any direct subobjects of o other
+  than inactive union members.
+The *constituent references* of an object o are
+- any direct members of o that have reference type, and
+- the constituent references of any direct subobjects of o other than
+  inactive union members.
+The constituent values and constituent references of a variable `x` are
+defined as follows:
+- If `x` declares an object, the constituent values and references of
+  that object are constituent values and references of `x`.
+- If `x` declares a reference, that reference is a constituent reference
+  of `x`.
+For any constituent reference `r` of a variable `x`, if `r` is bound to
+a temporary object or subobject thereof whose lifetime is extended to
+that of `r`, the constituent values and references of that temporary
+object are also constituent values and references of `x`, recursively.
+An object o is *constexpr-referenceable* from a point P if
+- o has static storage duration, or
+- o has automatic storage duration, and, letting `v` denote
+  - the variable corresponding to o’s complete object or
+  - the variable to whose lifetime that of o is extended,
+  the smallest scope enclosing `v` and the smallest scope enclosing P
+  that are neither
+  - block scopes nor
+  - function parameter scopes associated with a
+    *requirement-parameter-list*
+  are the same function parameter scope.
+[*Example 1*:
+``` cpp
+struct A {
+  int m;
+  const int& r;
+};
+void f() {
+  static int sx;
+  thread_local int tx;                  // tx is never constexpr-referenceable
+  int ax;
+  A aa = {1, 2};
+  static A sa = {3, 4};
+  // The objects sx, ax, and aa.m, sa.m, and the temporaries to which aa.r and sa.r are bound, are constexpr-referenceable.
+  auto lambda = [] {
+    int ay;
+    // The objects sx, sa.m, and ay (but not ax or aa), and the
+    // temporary to which sa.r is bound, are constexpr-referenceable.
+  };
+}
+```
+— *end example*]
+An object or reference `x` is *constexpr-representable* at a point P if,
+for each constituent value of `x` that points to or past an object o,
+and for each constituent reference of `x` that refers to an object o, o
+is constexpr-referenceable from P.
+A variable `v` is *constant-initializable* if
 - the full-expression of its initialization is a constant expression
+  when interpreted as a *constant-expression* with all contract
+ assertions using the ignore evaluation semantic
+ [[basic.contract.eval]], \[*Note 2*: Within this evaluation,
+ `std::is_constant_evaluated()` [[meta.const.eval]] returns
+ `true`. — *end note*] \[*Note 3*: The initialization, when evaluated,
+ can still evaluate contract assertions with other evaluation
+  semantics, resulting in a diagnostic or ill-formed program if a
+  contract violation occurs. — *end note*]
+- immediately after the initializing declaration of `v`, the object or
+  reference `x` declared by `v` is constexpr-representable, and
+- if `x` has static or thread storage duration, `x` is
+  constexpr-representable at the nearest point whose immediate scope is
+  a namespace scope that follows the initializing declaration of `v`.
+A constant-initializable variable is *constant-initialized* if either it
+has an initializer or its type is const-default-constructible
+[[dcl.init.general]].
+[*Example 2*:
+``` cpp
+void f() {
+  int ax = 0;                   // ax is constant-initialized
+  thread_local int tx = 0;      // tx is constant-initialized
+  static int sx;                // sx is not constant-initialized
+  static int& rss = sx;         // rss is constant-initialized
+  static int& rst = tx;         // rst is not constant-initialized
+  static int& rsa = ax;         // rsa is not constant-initialized
+  thread_local int& rts = sx;   // rts is constant-initialized
+  thread_local int& rtt = tx;   // rtt is not constant-initialized
+  thread_local int& rta = ax;   // rta is not constant-initialized
+  int& ras = sx;                // ras is constant-initialized
+  int& rat = tx;                // rat is not constant-initialized
+  int& raa = ax;                // raa is constant-initialized
+}
+```
+— *end example*]
 A variable is *potentially-constant* if it is constexpr or it has
 reference or non-volatile const-qualified integral or enumeration type.
 A constant-initialized potentially-constant variable V is *usable in
 - V is constexpr,
 - V is not initialized to a TU-local value, or
 - P is in the same translation unit as D.
+An object or reference is *potentially usable in constant expressions*
+at point P if it is
+- the object or reference declared by a variable that is usable in
+  constant expressions at P,
 - a temporary object of non-volatile const-qualified literal type whose
   lifetime is extended [[class.temporary]] to that of a variable that is
+  usable in constant expressions at P,
+- a template parameter object [[temp.param]],
+- a string literal object [[lex.string]],
+- a non-mutable subobject of any of the above, or
+- a reference member of any of the above.
+An object or reference is *usable in constant expressions* at point P if
+it is an object or reference that is potentially usable in constant
+expressions at P and is constexpr-representable at P.
+[*Example 3*:
+``` cpp
+struct A {
+  int* const & r;
+};
+void f(int x) {
+  constexpr A a = {&x};
+  static_assert(a.r == &x);             // OK
+  [&] {
+    static_assert(a.r != nullptr);      // error: a.r is not usable in constant expressions at this point
+  }();
+}
+```
+— *end example*]
 An expression E is a *core constant expression* unless the evaluation of
 E, following the rules of the abstract machine [[intro.execution]],
 would evaluate one of the following:
 - `this` [[expr.prim.this]], except
   - in a constexpr function [[dcl.constexpr]] that is being evaluated as
     part of E or
   - when appearing as the *postfix-expression* of an implicit or
     explicit class member access expression [[expr.ref]];
+- a control flow that passes through a declaration of a block variable
+  [[basic.scope.block]] with static [[basic.stc.static]] or thread
+ [[basic.stc.thread]] storage duration, unless that variable is usable
+ in constant expressions;
+  \[*Example 4*:
   ``` cpp
   constexpr char test() {
     static const int x = 5;
     static constexpr char c[] = "Hello World";
     return *(c + x);
   }
   static_assert(' ' == test());
   ```
   — *end example*]
+- an invocation of a non-constexpr function;[^29]
 - an invocation of an undefined constexpr function;
 - an invocation of an instantiated constexpr function that is not
   constexpr-suitable;
 - an invocation of a virtual function [[class.virtual]] for an object
   whose dynamic type is constexpr-unknown;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
+- an operation that would have undefined or erroneous behavior as
+ specified in [[intro]] through [[\lastcorechapter]];[^30]
 - an lvalue-to-rvalue conversion [[conv.lval]] unless it is applied to
+  - a glvalue of type cv `std::nullptr_t`,
   - a non-volatile glvalue that refers to an object that is usable in
     constant expressions, or
   - a non-volatile glvalue of literal type that refers to a non-volatile
     object whose lifetime began within the evaluation of E;
 - an lvalue-to-rvalue conversion that is applied to a glvalue that
   evaluation of E;
 - in a *lambda-expression*, a reference to `this` or to a variable with
   automatic storage duration defined outside that *lambda-expression*,
   where the reference would be an odr-use
   [[term.odr.use]], [[expr.prim.lambda]];
+  \[*Example 5*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
     };
   }
   ```
   — *end example*]
+  \[*Note 4*:
   If the odr-use occurs in an invocation of a function call operator of
   a closure type, it no longer refers to `this` or to an enclosing
+ variable with automatic storage duration due to the transformation
   [[expr.prim.lambda.capture]] of the *id-expression* into an access of
   the corresponding data member.
+  \[*Example 6*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
   static_assert(bind(monad(2))(monad)() == monad(2)());
   ```
   — *end example*]
   — *end note*]
+- a conversion from a prvalue `P` of type “pointer to cv `void`” to a
+  type “*cv1* pointer to `T`”, where `T` is not *cv2* `void`, unless `P`
+  is a null pointer value or points to an object whose type is similar
+  to `T`;
 - a `reinterpret_cast` [[expr.reinterpret.cast]];
 - a modification of an object
+  [[expr.assign]], [[expr.post.incr]], [[expr.pre.incr]] unless it is
   applied to a non-volatile lvalue of literal type that refers to a
   non-volatile object whose lifetime began within the evaluation of E;
 - an invocation of a destructor [[class.dtor]] or a function call whose
   *postfix-expression* names a pseudo-destructor [[expr.call]], in
   either case for an object whose lifetime did not begin within the
   evaluation of E;
+- a *new-expression* [[expr.new]], unless either
+ - the selected allocation function is a replaceable global allocation
+    function [[new.delete.single]], [[new.delete.array]] and the
+    allocated storage is deallocated within the evaluation of E, or
+  - the selected allocation function is a non-allocating form
+    [[new.delete.placement]] with an allocated type `T`, where
+    - the placement argument to the *new-expression* points to an object
+      whose type is similar to `T` [[conv.qual]] or, if `T` is an array
+      type, to the first element of an object of a type similar to `T`,
+      and
+    - the placement argument points to storage whose duration began
+      within the evaluation of E;
 - a *delete-expression* [[expr.delete]], unless it deallocates a region
   of storage allocated within the evaluation of E;
 - a call to an instance of `std::allocator<T>::allocate`
   [[allocator.members]], unless the allocated storage is deallocated
   within the evaluation of E;
 - a call to an instance of `std::allocator<T>::deallocate`
   [[allocator.members]], unless it deallocates a region of storage
   allocated within the evaluation of E;
+- a construction of an exception object, unless the exception object and
+  all of its implicit copies created by invocations of
+  `std::current_exception` or `std::rethrow_exception` [[propagation]]
+  are destroyed within the evaluation of E;
 - an *await-expression* [[expr.await]];
 - a *yield-expression* [[expr.yield]];
 - a three-way comparison [[expr.spaceship]], relational [[expr.rel]], or
   equality [[expr.eq]] operator where the result is unspecified;
 - a `dynamic_cast` [[expr.dynamic.cast]] or `typeid` [[expr.typeid]]
   expression on a glvalue that refers to an object whose dynamic type is
+  constexpr-unknown;
+- a `dynamic_cast` [[expr.dynamic.cast]] expression, `typeid`
+  [[expr.typeid]] expression, or `new-expression` [[expr.new]] that
+  would throw an exception where no definition of the exception type is
+  reachable;
+- an expression that would produce an injected declaration (see below),
+  unless E is the corresponding expression of a
+  *consteval-block-declaration* [[dcl.pre]];
 - an *asm-declaration* [[dcl.asm]];
 - an invocation of the `va_arg` macro [[cstdarg.syn]];
 - a non-constant library call [[defns.nonconst.libcall]]; or
+- a `goto` statement [[stmt.goto]]. \[*Note 5*: A `goto` statement
+  introduced by equivalence [[stmt]] is not in scope. For example, a
+  `while` statement [[stmt.while]] can be executed during constant
+  evaluation. — *end note*]
+It is *implementation-defined* whether E is a core constant expression
+if E satisfies the constraints of a core constant expression, but
+evaluation of E has runtime-undefined behavior.
 It is unspecified whether E is a core constant expression if E satisfies
 the constraints of a core constant expression, but evaluation of E would
 evaluate
 - an operation that has undefined behavior as specified in [[library]]
+  through [[exec]] or
+- an invocation of the `va_start` macro [[cstdarg.syn]].
+[*Example 7*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
 — *end example*]
 For the purposes of determining whether an expression E is a core
 constant expression, the evaluation of the body of a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
+literal type, is ignored.
 For the purposes of determining whether E is a core constant expression,
 the evaluation of a call to a trivial copy/move constructor or copy/move
 assignment operator of a union is considered to copy/move the active
 member of the union, if any.
+[*Note 6*: The copy/move of the active member is
 trivial. — *end note*]
+For the purposes of determining whether E is a core constant expression,
+the evaluation of an *id-expression* that names a structured binding `v`
+[[dcl.struct.bind]] has the following semantics:
+- If `v` is an lvalue referring to the object bound to an invented
+  reference `r`, the behavior is as if `r` were nominated.
+- Otherwise, if `v` names an array element or class member, the behavior
+  is that of evaluating `e[i]` or `e.m`, respectively, where e is the
+  name of the variable initialized from the initializer of the
+  structured binding declaration, and i is the index of the element
+  referred to by `v` or m is the name of the member referred to by `v`,
+  respectively.
+[*Example 8*:
+``` cpp
+#include <tuple>
+struct S {
+  mutable int m;
+  constexpr S(int m): m(m) {}
+  virtual int g() const;
+};
+void f(std::tuple<S&> t) {
+  auto [r] = t;
+  static_assert(r.g() >= 0);            // error: dynamic type is constexpr-unknown
+  constexpr auto [m] = S(1);
+  static_assert(m == 1);                // error: lvalue-to-rvalue conversion on mutable
+                                        // subobject e.m, where e is a constexpr object of type S
+  using A = int[2];
+  constexpr auto [v0, v1] = A{2, 3};
+  static_assert(v0 + v1 == 5);          // OK, equivalent to e[0] + e[1] where e is a constexpr array
+}
+```
+— *end example*]
 During the evaluation of an expression E as a core constant expression,
+all *id-expression*s, *splice-expression*s, and uses of `*this` that
+refer to an object or reference whose lifetime did not begin with the
+evaluation of E are treated as referring to a specific instance of that
+object or reference whose lifetime and that of all subobjects (including
+all union members) includes the entire constant evaluation. For such an
+object that is not usable in constant expressions, the dynamic type of
+the object is *constexpr-unknown*. For such a reference that is not
+usable in constant expressions, the reference is treated as binding to
+an unspecified object of the referenced type whose lifetime and that of
+all subobjects includes the entire constant evaluation and whose dynamic
+type is constexpr-unknown.
+[*Example 9*:
 ``` cpp
 template <typename T, size_t N>
 constexpr size_t array_size(T (&)[N]) {
   return N;
 constexpr auto& gallagher = typeid(trident);    // error: constexpr-unknown dynamic type
 ```
 — *end example*]
+An object `a` is said to have *constant destruction* if
 - it is not of class type nor (possibly multidimensional) array thereof,
   or
 - it is of class type or (possibly multidimensional) array thereof, that
+  class type has a constexpr destructor [[dcl.constexpr]], and for a
+ hypothetical expression E whose only effect is to destroy `a`, E would
+ be a core constant expression if the lifetime of `a` and its
+ non-mutable subobjects (but not its mutable subobjects) were
+ considered to start within E.
 An *integral constant expression* is an expression of integral or
 unscoped enumeration type, implicitly converted to a prvalue, where the
 converted expression is a core constant expression.
+[*Note 7*: Such expressions can be used as bit-field lengths
 [[class.bit]], as enumerator initializers if the underlying type is not
 fixed [[dcl.enum]], and as alignments [[dcl.align]]. — *end note*]
 If an expression of literal class type is used in a context where an
 integral constant expression is required, then that expression is
 contextually implicitly converted [[conv]] to an integral or unscoped
 enumeration type and the selected conversion function shall be
 `constexpr`.
+[*Example 10*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
 - function-to-pointer conversions [[conv.func]],
 - qualification conversions [[conv.qual]],
 - integral promotions [[conv.prom]],
 - integral conversions [[conv.integral]] other than narrowing
   conversions [[dcl.init.list]],
+- floating-point promotions [[conv.fpprom]],
+- floating-point conversions [[conv.double]] where the source value can
+  be represented exactly in the destination type,
 - null pointer conversions [[conv.ptr]] from `std::nullptr_t`,
 - null member pointer conversions [[conv.mem]] from `std::nullptr_t`,
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
+[*Note 8*: Such expressions can be used in `new` expressions
 [[expr.new]], as case expressions [[stmt.switch]], as enumerator
 initializers if the underlying type is fixed [[dcl.enum]], as array
+bounds [[dcl.array]], as constant template arguments [[temp.arg]], and
+as the constant expression of a *splice-specifier*
+[[basic.splice]]. — *end note*]
 A *contextually converted constant expression of type `bool`* is an
 expression, contextually converted to `bool` [[conv]], where the
 converted expression is a constant expression and the conversion
 sequence contains only the conversions above.
+A *constant expression* is either
+- a glvalue core constant expression E for which
+ - E refers to a non-immediate function,
+ - E designates an object `o`, and if the complete object of `o` is of
+    consteval-only type then so is E,
+    \[*Example 11*:
+    ``` cpp
+    struct Base { };
+    struct Derived : Base { std::meta::info r; };
+    consteval const Base& fn(const Derived& derived) { return derived; }
+    constexpr Derived obj{.r=^^::};     // OK
+    constexpr const Derived& d = obj;   // OK
+    constexpr const Base& b = fn(obj);  // error: not a constant expression because Derived
+                                        // is a consteval-only type but Base is not.
+    ```
+    — *end example*]
+  or
+- a prvalue core constant expression whose result object [[basic.lval]]
+  satisfies the following constraints:
+  - each constituent reference refers to an object or a non-immediate
+    function,
+  - no constituent value of scalar type is an indeterminate or erroneous
+    value [[basic.indet]],
+  - no constituent value of pointer type is a pointer to an immediate
+    function or an invalid pointer value [[basic.compound]],
+  - no constituent value of pointer-to-member type designates an
+    immediate function, and
+  - unless the value is of consteval-only type,
+    - no constituent value of pointer-to-member type points to a direct
+      member of a consteval-only class type,
+    - no constituent value of pointer type points to or past an object
+      whose complete object is of consteval-only type, and
+    - no constituent reference refers to an object whose complete object
+      is of consteval-only type.
+[*Note 9*: A glvalue core constant expression that either refers to or
 points to an unspecified object is not a constant
 expression. — *end note*]
+[*Example 12*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
 constexpr int r = h();                          // OK
 constexpr auto e = g();                         // error: a pointer to an immediate function is
                                                 // not a permitted result of a constant expression
+struct S {
+  int x;
+  constexpr S() {}
+};
+int i() {
+  constexpr S s;                                // error: s.x has erroneous value
+}
 ```
 — *end example*]
 *Recommended practice:* Implementations should provide consistent
 results of floating-point evaluations, irrespective of whether the
 evaluation is performed during translation or during program execution.
+[*Note 10*:
 Since this document imposes no restrictions on the accuracy of
 floating-point operations, it is unspecified whether the evaluation of a
 floating-point expression during translation yields the same result as
 the evaluation of the same expression (or the same operations on the
 same values) during program execution.
+[*Example 13*:
 ``` cpp
 bool f() {
     char array[1 + int(1 + 0.2 - 0.1 - 0.1)];   // Must be evaluated during translation
     int size = 1 + int(1 + 0.2 - 0.1 - 0.1);    // May be evaluated at runtime
 function and is not in an immediate function context. An aggregate
 initialization is an immediate invocation if it evaluates a default
 member initializer that has a subexpression that is an
 immediate-escalating expression.
+A potentially-evaluated expression or conversion is
+*immediate-escalating* if it is neither initially in an immediate
+function context nor a subexpression of an immediate invocation, and
+- it is an *id-expression* or *splice-expression* that designates an
+  immediate function,
+- it is an immediate invocation that is not a constant expression, or
+- it is of consteval-only type [[basic.types.general]].
 An *immediate-escalating* function is
 - the call operator of a lambda that is not declared with the
   `consteval` specifier,
   defined with the `constexpr` specifier.
 An immediate-escalating expression shall appear only in an
 immediate-escalating function.
+An *immediate function* is a function that is either
 - declared with the `consteval` specifier, or
+- an immediate-escalating function `F` whose function body contains
+ either
+  - an immediate-escalating expression or
+  - a definition of a non-constexpr variable with consteval-only type
+  whose innermost enclosing non-block scope is `F`’s function parameter
+  scope.
+[*Example 14*:
 ``` cpp
 consteval int id(int i) { return i; }
 constexpr char id(char c) { return c; }
 int x = 0;
 template<class T>
 constexpr T h(T t = id(x)) {    // h<int> is not an immediate function
+                                // id(x) is not evaluated when parsing the default argument[dcl.fct.default,temp.inst]
     return t;
 }
 template<class T>
+constexpr T hh() {              // hh<int> is an immediate function because of the invocation
+  return h<T>();                // of the immediate function id in the default argument of h<int>
 }
 int i = hh<int>();              // error: hh<int>() is an immediate-escalating expression
                                 // outside of an immediate-escalating function
 template<class T>
 constexpr int k(int) {          // k<int> is not an immediate function because A(42) is a
   return A(42).y;               // constant expression and thus not immediate-escalating
 }
+constexpr int l(int c) pre(c >= 2) {
+  return (c % 2 == 0) ? c / 0 : c;
+}
+const int i0 = l(0);    // dynamic initialization; contract violation or undefined behavior
+const int i1 = l(1);    // static initialization; value of 1 or contract violation at compile time
+const int i2 = l(2);    // dynamic initialization; undefined behavior
+const int i3 = l(3);    // static initialization; value of 3
 ```
 — *end example*]
 An expression or conversion is *manifestly constant-evaluated* if it is:
 - the condition of a constexpr if statement [[stmt.if]], or
 - an immediate invocation, or
 - the result of substitution into an atomic constraint expression to
   determine whether it is satisfied [[temp.constr.atomic]], or
 - the initializer of a variable that is usable in constant expressions
+  or has constant initialization [[basic.start.static]].[^31]
+  \[*Example 15*:
   ``` cpp
   template<bool> struct X {};
   X<std::is_constant_evaluated()> x;                      // type X<true>
   int y;
   const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
+[*Note 11*: Except for a *static_assert-message*, a manifestly
+constant-evaluated expression is evaluated even in an unevaluated
+operand [[term.unevaluated.operand]]. — *end note*]
+The evaluation of an expression can introduce one or more *injected
+declarations*. The evaluation is said to *produce* the declarations.
+[*Note 12*: An invocation of the library function template
+`std::meta::define_aggregate` produces an injected declaration
+[[meta.reflection.define.aggregate]]. — *end note*]
+Each such declaration has
+- an associated *synthesized point*, which follows the last
+  non-synthesized program point in the translation unit containing that
+  declaration, and
+- an associated *characteristic sequence* of values.
+[*Note 13*: Special rules concerning reachability apply to synthesized
+points [[module.reach]]. — *end note*]
+[*Note 14*: The program is ill-formed if injected declarations with
+different characteristic sequences define the same entity in different
+translation units [[basic.def.odr]]. — *end note*]
+A member of an entity defined by an injected declaration shall not have
+a name reserved to the implementation [[lex.name]]; no diagnostic is
+required.
+Let C be a *consteval-block-declaration*, the evaluation of whose
+corresponding expression produces an injected declaration for an entity
+E. The program is ill-formed if either
+- C is enclosed by a scope associated with E or
+- letting P be a point whose immediate scope is that to which E belongs,
+  there is a function parameter scope or class scope that encloses
+  exactly one of C or P.
+[*Example 16*:
+``` cpp
+struct S0 {
+  consteval {
+    std::meta::define_aggregate(^^S0, {});  // error: scope associated with S0 encloses the consteval block
+  }
+};
+struct S1;
+consteval { std::meta::define_aggregate(^^S1, {}); }    // OK
+template <std::meta::info R> consteval void tfn1() {
+  std::meta::define_aggregate(R, {});
+}
+struct S2;
+consteval { tfn1<^^S2>(); }                             // OK
+template <std::meta::info R> consteval void tfn2() {
+  consteval { std::meta::define_aggregate(R, {}); }
+}
+struct S3;
+consteval { tfn2<^^S3>(); }
+  // error: function parameter scope of tfn2<^^ S3> intervenes between the declaration of S3
+  // and the consteval block that produces the injected declaration
+template <typename> struct TCls {
+  struct S4;
+  static void sfn() requires ([] {
+    consteval { std::meta::define_aggregate(^^S4, {}); }
+    return true;
+  }()) { }
+};
+consteval { TCls<void>::sfn(); }    // error: TCls<void>::S4 is not enclosed by requires-clause lambda
+struct S5;
+struct Cls {
+  consteval { std::meta::define_aggregate(^^S5, {}); }  // error: S5 is not enclosed by class Cls
+};
+struct S6;
+consteval {                                 // #1
+  struct S7;                                // local class
+  std::meta::define_aggregate(^^S7, {});    // error: consteval block #1 does not enclose itself,
+                                            // but encloses S7
+  struct S8;                                // local class
+  consteval {                               // #2
+    std::meta::define_aggregate(^^S6, {});  // error: consteval block #1 encloses
+                                            // consteval block #2 but not S6
+    std::meta::define_aggregate(^^S8, {});  // OK, consteval block #1 encloses both #2 and S8
+  }
+}
+```
+— *end example*]
+The *evaluation context* is a set of program points that determines the
+behavior of certain functions used for reflection [[meta.reflection]].
+During the evaluation V of an expression E as a core constant
+expression, the evaluation context of an evaluation X
+[[intro.execution]] consists of the following points:
+- The program point EVAL-PT(L), where L is the point at which E appears,
+  and where EVAL-PT(P), for a point P, is a point R determined as
+  follows:
+  - If a potentially-evaluated subexpression [[intro.execution]] of a
+    default member initializer I appears at P, and a (possibly
+    aggregate) initialization during V is using I, then R is EVAL-PT(Q)
+    where Q is the point at which that initialization appears.
+  - Otherwise, if a potentially-evaluated subexpression of a default
+    argument [[dcl.fct.default]] appears at P, and an invocation of a
+    function [[expr.call]] during V is using that default argument, then
+    R is EVAL-PT(Q) where Q is the point at which that invocation
+    appears.
+  - Otherwise, R is P.
+- Each synthesized point corresponding to an injected declaration
+  produced by any evaluation sequenced before X [[intro.execution]].
 An expression or conversion is *potentially constant evaluated* if it
 is:
 - a manifestly constant-evaluated expression,
 - a potentially-evaluated expression [[basic.def.odr]],
+- an immediate subexpression of a *braced-init-list*,[^32]
 - an expression of the form `&` *cast-expression* that occurs within a
+  templated entity,[^33] or
 - a potentially-evaluated subexpression [[intro.execution]] of one of
   the above.
 A function or variable is *needed for constant evaluation* if it is:
   that is potentially constant evaluated, or
 - a potentially-constant variable named by a potentially constant
   evaluated expression.
 <!-- Link reference definitions -->
+[\lastcorechapter]: #\lastcorechapter
 [allocator.members]: mem.md#allocator.members
 [bad.alloc]: support.md#bad.alloc
 [bad.cast]: support.md#bad.cast
 [bad.typeid]: support.md#bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.compound]: basic.md#basic.compound
+[basic.contract]: basic.md#basic.contract
+[basic.contract.eval]: basic.md#basic.contract.eval
+[basic.contract.general]: basic.md#basic.contract.general
 [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.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
+[basic.namespace]: dcl.md#basic.namespace
 [basic.pre]: basic.md#basic.pre
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
+[basic.scope.contract]: basic.md#basic.scope.contract
 [basic.scope.lambda]: basic.md#basic.scope.lambda
+[basic.splice]: basic.md#basic.splice
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
+[basic.types.general]: basic.md#basic.types.general
 [class]: class.md#class
 [class.abstract]: class.md#class.abstract
 [class.access]: class.md#class.access
 [class.access.base]: class.md#class.access.base
+[class.access.general]: class.md#class.access.general
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
 [class.cdtor]: class.md#class.cdtor
 [class.conv]: class.md#class.conv
 [class.conv.fct]: class.md#class.conv.fct
 [class.derived]: class.md#class.derived
 [class.dtor]: class.md#class.dtor
 [class.free]: class.md#class.free
 [class.friend]: class.md#class.friend
 [class.mem]: class.md#class.mem
+[class.mem.general]: class.md#class.mem.general
 [class.member.lookup]: basic.md#class.member.lookup
 [class.mfct.non.static]: class.md#class.mfct.non.static
 [class.mi]: class.md#class.mi
+[class.pre]: class.md#class.pre
 [class.prop]: class.md#class.prop
 [class.spaceship]: class.md#class.spaceship
 [class.static.mfct]: class.md#class.static.mfct
 [class.temporary]: basic.md#class.temporary
 [class.union]: class.md#class.union
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [conv.qual]: #conv.qual
 [conv.rank]: basic.md#conv.rank
 [conv.rval]: #conv.rval
 [cstdarg.syn]: support.md#cstdarg.syn
 [cstddef.syn]: support.md#cstddef.syn
+[dcl]: dcl.md#dcl
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.asm]: dcl.md#dcl.asm
+[dcl.attr.annotation]: dcl.md#dcl.attr.annotation
 [dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.contract.func]: dcl.md#dcl.contract.func
+[dcl.contract.res]: dcl.md#dcl.contract.res
 [dcl.decl]: dcl.md#dcl.decl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.coroutine]: dcl.md#dcl.fct.def.coroutine
 [dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.general]: dcl.md#dcl.init.general
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [dcl.init.string]: dcl.md#dcl.init.string
 [dcl.link]: dcl.md#dcl.link
 [dcl.mptr]: dcl.md#dcl.mptr
 [dcl.name]: dcl.md#dcl.name
+[dcl.pre]: dcl.md#dcl.pre
 [dcl.ptr]: dcl.md#dcl.ptr
 [dcl.ref]: dcl.md#dcl.ref
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.spec.auto.general]: dcl.md#dcl.spec.auto.general
 [dcl.stc]: dcl.md#dcl.stc
 [dcl.struct.bind]: dcl.md#dcl.struct.bind
 [dcl.type]: dcl.md#dcl.type
 [dcl.type.auto.deduct]: dcl.md#dcl.type.auto.deduct
+[dcl.type.class.deduct]: dcl.md#dcl.type.class.deduct
 [dcl.type.cv]: dcl.md#dcl.type.cv
 [dcl.type.decltype]: dcl.md#dcl.type.decltype
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [defns.nonconst.libcall]: intro.md#defns.nonconst.libcall
 [depr.capture.this]: future.md#depr.capture.this
 [depr.volatile.type]: future.md#depr.volatile.type
 [except]: except.md#except
+[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.terminate]: except.md#except.terminate
 [except.throw]: except.md#except.throw
+[exec]: exec.md#exec
 [expr]: #expr
 [expr.add]: #expr.add
 [expr.alignof]: #expr.alignof
 [expr.arith.conv]: #expr.arith.conv
+[expr.assign]: #expr.assign
 [expr.await]: #expr.await
 [expr.bit.and]: #expr.bit.and
 [expr.call]: #expr.call
 [expr.cast]: #expr.cast
 [expr.comma]: #expr.comma
 [expr.post.incr]: #expr.post.incr
 [expr.pre]: #expr.pre
 [expr.pre.incr]: #expr.pre.incr
 [expr.prim]: #expr.prim
 [expr.prim.fold]: #expr.prim.fold
+[expr.prim.grammar]: #expr.prim.grammar
 [expr.prim.id]: #expr.prim.id
 [expr.prim.id.dtor]: #expr.prim.id.dtor
 [expr.prim.id.general]: #expr.prim.id.general
 [expr.prim.id.qual]: #expr.prim.id.qual
 [expr.prim.id.unqual]: #expr.prim.id.unqual
 [expr.prim.lambda]: #expr.prim.lambda
 [expr.prim.lambda.capture]: #expr.prim.lambda.capture
 [expr.prim.lambda.closure]: #expr.prim.lambda.closure
 [expr.prim.lambda.general]: #expr.prim.lambda.general
 [expr.prim.literal]: #expr.prim.literal
+[expr.prim.pack.index]: #expr.prim.pack.index
 [expr.prim.paren]: #expr.prim.paren
 [expr.prim.req]: #expr.prim.req
 [expr.prim.req.compound]: #expr.prim.req.compound
 [expr.prim.req.general]: #expr.prim.req.general
 [expr.prim.req.nested]: #expr.prim.req.nested
 [expr.prim.req.simple]: #expr.prim.req.simple
 [expr.prim.req.type]: #expr.prim.req.type
+[expr.prim.splice]: #expr.prim.splice
 [expr.prim.this]: #expr.prim.this
 [expr.prop]: #expr.prop
 [expr.ref]: #expr.ref
+[expr.reflect]: #expr.reflect
 [expr.reinterpret.cast]: #expr.reinterpret.cast
 [expr.rel]: #expr.rel
 [expr.shift]: #expr.shift
 [expr.sizeof]: #expr.sizeof
 [expr.spaceship]: #expr.spaceship
 [intro.memory]: basic.md#intro.memory
 [intro.object]: basic.md#intro.object
 [lex.ext]: lex.md#lex.ext
 [lex.icon]: lex.md#lex.icon
 [lex.literal]: lex.md#lex.literal
+[lex.name]: lex.md#lex.name
 [lex.string]: lex.md#lex.string
 [library]: library.md#library
 [meta.const.eval]: meta.md#meta.const.eval
+[meta.reflection]: meta.md#meta.reflection
+[meta.reflection.define.aggregate]: meta.md#meta.reflection.define.aggregate
+[module.reach]: module.md#module.reach
+[namespace.alias]: dcl.md#namespace.alias
 [namespace.udecl]: dcl.md#namespace.udecl
 [new.badlength]: support.md#new.badlength
 [new.delete.array]: support.md#new.delete.array
 [new.delete.placement]: support.md#new.delete.placement
 [new.delete.single]: support.md#new.delete.single
 [over]: over.md#over
+[over.assign]: over.md#over.assign
 [over.best.ics]: over.md#over.best.ics
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.call.func]: over.md#over.call.func
 [over.ics.user]: over.md#over.ics.user
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.class.deduct]: over.md#over.match.class.deduct
+[over.match.funcs]: over.md#over.match.funcs
 [over.match.oper]: over.md#over.match.oper
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [over.sub]: over.md#over.sub
+[propagation]: support.md#propagation
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [std.modules]: library.md#std.modules
+[stmt]: stmt.md#stmt
+[stmt.contract.assert]: stmt.md#stmt.contract.assert
 [stmt.goto]: stmt.md#stmt.goto
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.switch]: stmt.md#stmt.switch
+[stmt.while]: stmt.md#stmt.while
 [support.runtime]: support.md#support.runtime
 [support.types.layout]: support.md#support.types.layout
+[temp.alias]: temp.md#temp.alias
 [temp.arg]: temp.md#temp.arg
 [temp.concept]: temp.md#temp.concept
 [temp.constr.atomic]: temp.md#temp.constr.atomic
 [temp.constr.constr]: temp.md#temp.constr.constr
 [temp.constr.decl]: temp.md#temp.constr.decl
+[temp.deduct.general]: temp.md#temp.deduct.general
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
+[temp.dep.type]: temp.md#temp.dep.type
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.over.link]: temp.md#temp.over.link
 [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.type]: temp.md#temp.type
 [temp.variadic]: temp.md#temp.variadic
 [term.incomplete.type]: basic.md#term.incomplete.type
 [term.object.representation]: basic.md#term.object.representation
 [term.odr.use]: basic.md#term.odr.use
+[term.structural.type]: temp.md#term.structural.type
 [term.unevaluated.operand]: #term.unevaluated.operand
 [type.info]: support.md#type.info
 [typeinfo.syn]: support.md#typeinfo.syn
 [^1]: The precedence of operators is not directly specified, but it can
     be derived from the syntax.
 [^2]: Overloaded operators are never assumed to be associative or
     commutative.
 [^3]: The cast and assignment operators must still perform their
     specific conversions as described in  [[expr.type.conv]],
+    [[expr.cast]], [[expr.static.cast]] and  [[expr.assign]].
 [^4]: The intent of this list is to specify those circumstances in which
     an object can or cannot be aliased.
 [^5]: For historical reasons, this conversion is called the
     “lvalue-to-rvalue” conversion, even though that name does not
     accurately reflect the taxonomy of expressions described in
     [[basic.lval]].
 [^6]: In C++ class and array prvalues can have cv-qualified types. This
+    differs from C, in which non-lvalues never have cv-qualified types.
 [^7]: This conversion never applies to non-static member functions
     because an lvalue that refers to a non-static member function cannot
     be obtained.
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
     `char32_t`, `wchar_t`, or of enumeration type are converted to some
     integral type.
+[^10]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
+[^11]: Note that `(*(E1))` is an lvalue.
 [^12]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
+[^13]: The most derived object [[intro.object]] pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
+[^14]: The recommended name for such a class is `extended_type_info`.
+[^15]: The types can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^16]: `T1` and `T2` can have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^17]: This is sometimes referred to as a type pun when the result
     refers to the same object as the source glvalue.
+[^18]: `const_cast` is not limited to conversions that cast away a
     const-qualifier.
+[^19]: `sizeof``(``bool``)` is not required to be `1`.
+[^20]: The actual size of a potentially-overlapping subobject can be
     less than the result of applying `sizeof` to the subobject, due to
     virtual base classes and less strict padding requirements on
     potentially-overlapping subobjects.
+[^21]: If the conversion function returns a signed integer type, the
     second standard conversion converts to the unsigned type
     `std::size_t` and thus thwarts any attempt to detect a negative
     value afterwards.
+[^22]: This can include evaluating a *new-initializer* and/or calling a
     constructor.
+[^23]: A *lambda-expression* with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the
     *lambda-expression* is enclosed in parentheses.
+[^24]: For nonzero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
+[^25]: This is often called truncation towards zero.
+[^26]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
+[^27]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose and a pointer past the last element of an array of n
     elements is considered to be equivalent to a pointer to a
     hypothetical array element n for this purpose.
+[^28]: As specified in [[basic.compound]], an object that is not an
     array element is considered to belong to a single-element array for
     this purpose.
+[^29]: Overload resolution [[over.match]] is applied as usual.
+[^30]: This includes, for example, signed integer overflow [[expr.pre]],
     certain pointer arithmetic [[expr.add]], division by zero
     [[expr.mul]], or certain shift operations [[expr.shift]].
+[^31]: Testing this condition can involve a trial evaluation of its
+    initializer, with evaluations of contract assertions using the
+    ignore evaluation semantic [[basic.contract.eval]], as described
+    above.
+[^32]: In some cases, constant evaluation is needed to determine whether
     a narrowing conversion is performed [[dcl.init.list]].
+[^33]: In some cases, constant evaluation is needed to determine whether
     such an expression is value-dependent [[temp.dep.constexpr]].

Diff to HTML by rtfpessoa