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

Files changed (1) hide show

tmp/tmpweavc5q2/{from.md → to.md} +352 -134

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

@@ -21,23 +21,23 @@ A variable or temporary object `o` is *constant-initialized* if
   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 may 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 const-qualified integral or enumeration type.
-A constant-initialized potentially-constant variable is *usable in
-constant expressions* at a point P if its initializing declaration D is
 reachable from P and
-- it is constexpr,
-- it 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
@@ -50,52 +50,57 @@ An object or reference is *usable in constant expressions* if it is
 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;
-- an invocation of a non-constexpr function \[*Note 3*: Overload
- resolution [[over.match]] is applied as usual. — *end note*] ;
 - an invocation of an undefined constexpr function;
-- an invocation of an instantiated constexpr function that fails to
- satisfy the requirements for a constexpr function;
 - an invocation of a virtual function [[class.virtual]] for an object
- unless
-  - the object is usable in constant expressions or
-  - its lifetime began within the evaluation of E;
 - an expression that would exceed the implementation-defined limits (see
   [[implimits]]);
 - an operation that would have undefined behavior as specified in
-  [[intro]] through [[cpp]] of this document \[*Note 4*: including, for
-  example, signed integer overflow [[expr.prop]], certain pointer
-  arithmetic [[expr.add]], division by zero [[expr.mul]], or certain
-  shift operations [[expr.shift]] — *end note*] ;
 - 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 [[conv.lval]] that is applied to a
- glvalue that refers to a non-active member of a union or a subobject
-  thereof;
 - an lvalue-to-rvalue conversion that is applied to an object with an
   indeterminate value [[basic.indet]];
 - an invocation of an implicitly-defined copy/move constructor or
   copy/move assignment operator for a union whose active member (if any)
   is mutable, unless the lifetime of the union object began within the
   evaluation of E;
-- an *id-expression* that refers to a variable or data member of
-  reference type unless the reference has a preceding initialization and
-  either
-  - it is usable in constant expressions or
-  - its lifetime began within the 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 ([[basic.def.odr]],
-  [[expr.prim.lambda]]);
-  \[*Example 1*:
   ``` cpp
   void g() {
     const int n = 0;
     [=] {
       constexpr int i = n;        // OK, n is not odr-used here
@@ -103,17 +108,17 @@ would evaluate one of the following:
     };
   }
   ```
   — *end example*]
-  \[*Note 5*:
   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 2*:
   ``` cpp
   auto monad = [](auto v) { return [=] { return v; }; };
   auto bind = [](auto m) {
     return [=](auto fvm) { return fvm(m()); };
   };
@@ -124,17 +129,21 @@ would evaluate one of the following:
   — *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;
 - 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
@@ -144,41 +153,53 @@ would evaluate one of the following:
   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]] or a dynamic cast
- [[expr.dynamic.cast]] or `typeid` [[expr.typeid]] expression that
- would throw an exception;
-- an *asm-declaration* [[dcl.asm]]; or
-- an invocation of the `va_arg` macro [[cstdarg.syn]].
-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]] of this document, or an
-invocation of the `va_start` macro [[cstdarg.syn]], it is unspecified
-whether E is a core constant expression.
-[*Example 3*:
 ``` cpp
 int x;                              // not constant
 struct A {
   constexpr A(bool b) : m(b?42:x) { }
   int m;
 };
-constexpr int v = A(true).m;        // OK: constructor call initializes m with the value 42
 constexpr int w = A(false).m;       // error: initializer for m is x, which is non-constant
 constexpr int f1(int k) {
   constexpr int x = k;              // error: x is not initialized by a constant expression
                                     // because lifetime of k began outside the initializer of x
   return x;
 }
 constexpr int f2(int k) {
-  int x = k;                        // OK: not required to be a constant expression
                                     // because x is not constexpr
   return x;
 }
 constexpr int incr(int &n) {
@@ -188,67 +209,132 @@ constexpr int g(int k) {
   constexpr int x = incr(k);        // error: incr(k) is not a core constant expression
                                     // because lifetime of k began outside the expression incr(k)
   return x;
 }
 constexpr int h(int k) {
-  int x = incr(k);                  // OK: incr(k) is not required to be a core constant expression
   return x;
 }
-constexpr int y = h(1);             // OK: initializes y with the value 2
                                     // h(1) is a core constant expression because
                                     // the lifetime of k begins inside h(1)
 ```
 — *end example*]
 For the purposes of determining whether an expression E is a core
-constant expression, the evaluation of a call to a member function of
 `std::allocator<T>` as defined in [[allocator.members]], where `T` is a
-literal type, does not disqualify E from being a core constant
-expression, even if the actual evaluation of such a call would otherwise
-fail the requirements for a core constant expression. Similarly, the
-evaluation of a call to `std::destroy_at`, `std::ranges::destroy_at`,
-`std::construct_at`, or `std::ranges::construct_at` does not disqualify
-E from being a core constant expression unless:
-- for a call to `std::construct_at` or `std::ranges::construct_at`, the
-  first argument, of type `T*`, does not point to storage allocated with
-  `std::allocator<T>` or to an object whose lifetime began within the
-  evaluation of E, or the evaluation of the underlying constructor call
-  disqualifies E from being a core constant expression, or
-- for a call to `std::destroy_at` or `std::ranges::destroy_at`, the
-  first argument, of type `T*`, does not point to storage allocated with
-  `std::allocator<T>` or to an object whose lifetime began within the
-  evaluation of E, or the evaluation of the underlying destructor call
-  disqualifies E from being a core constant expression.
 An object `a` is said to have *constant destruction* if:
-- it is not of class type nor (possibly multi-dimensional) array
- thereof, or
-- it is of class type or (possibly multi-dimensional) 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 may 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 4*:
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
   constexpr operator int() const { return val; }
@@ -280,11 +366,11 @@ constant expression and the implicit conversion sequence contains only
   and
 - function pointer conversions [[conv.fctptr]],
 and where the reference binding (if any) binds directly.
-[*Note 7*: Such expressions may 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*]
@@ -299,10 +385,12 @@ 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 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
@@ -313,11 +401,15 @@ whose value satisfies the following constraints:
 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.
-[*Example 5*:
 ``` cpp
 consteval int f() { return 42; }
 consteval auto g() { return f; }
 consteval int h(int (*p)() = g()) { return p(); }
@@ -326,19 +418,23 @@ constexpr auto e = g();                         // error: a pointer to an immedi
                                                 // not a permitted result of a constant expression
 ```
 — *end example*]
-[*Note 8*:
 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.[^32]
-[*Example 6*:
 ``` 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
@@ -351,27 +447,121 @@ It is unspecified whether the value of `f()` will be `true` or `false`.
 — *end example*]
 — *end note*]
 An expression or conversion is in an *immediate function context* if it
-is potentially evaluated and its innermost non-block scope is a function
-parameter scope of an immediate function. An expression or conversion is
-an *immediate invocation* if it is a potentially-evaluated explicit or
-implicit invocation of an immediate function and is not in an immediate
-function context. An immediate invocation shall be a constant
-expression.
 An expression or conversion is *manifestly constant-evaluated* if it is:
 - a *constant-expression*, or
 - 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.[^33]
-  \[*Example 7*:
   ``` 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
@@ -380,44 +570,44 @@ An expression or conversion is *manifestly constant-evaluated* if it is:
   const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
   int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to y+y
   constexpr int f() {
     const int n = std::is_constant_evaluated() ? 13 : 17; // n is 13
-    int m = std::is_constant_evaluated() ? 13 : 17;       // m might be 13 or 17 (see below)
     char arr[n] = {}; // char[13]
     return m + sizeof(arr);
   }
   int p = f();                                            // m is 13; initialized to 26
   int q = p + f();                                        // m is 17 for this call; initialized to 56
   ```
   — *end example*]
-[*Note 9*: A manifestly constant-evaluated expression is evaluated even
-in an 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*, [^34]
 - an expression of the form `&` *cast-expression* that occurs within a
-  templated entity, [^35] or
-- a subexpression of one of the above that is not a subexpression of a
- nested unevaluated operand.
 A function or variable is *needed for constant evaluation* if it is:
 - a constexpr function that is named by an expression [[basic.def.odr]]
   that is potentially constant evaluated, or
-- a variable whose name appears as a potentially constant evaluated
- expression that is either a constexpr variable or is of non-volatile
-  const-qualified integral type or of reference type.
 <!-- Link reference definitions -->
-[allocator.members]: utilities.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
@@ -425,23 +615,26 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.classref]: basic.md#basic.lookup.classref
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: #basic.lval
-[basic.namespace]: dcl.md#basic.namespace
 [basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.class]: basic.md#basic.scope.class
 [basic.start.main]: basic.md#basic.start.main
 [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.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.type.qualifier]: basic.md#basic.type.qualifier
-[basic.types]: basic.md#basic.types
 [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
@@ -456,31 +649,32 @@ 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]: class.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.qual]: basic.md#class.qual
 [class.spaceship]: class.md#class.spaceship
-[class.static]: class.md#class.static
 [class.temporary]: basic.md#class.temporary
-[class.this]: class.md#class.this
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [cmp.categories]: support.md#cmp.categories
 [conv]: #conv
 [conv.array]: #conv.array
 [conv.bool]: #conv.bool
 [conv.double]: #conv.double
 [conv.fctptr]: #conv.fctptr
 [conv.fpint]: #conv.fpint
 [conv.fpprom]: #conv.fpprom
 [conv.func]: #conv.func
 [conv.integral]: #conv.integral
 [conv.lval]: #conv.lval
 [conv.mem]: #conv.mem
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
@@ -491,10 +685,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.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
@@ -514,17 +709,20 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.cv]: dcl.md#dcl.type.cv
 [dcl.type.simple]: dcl.md#dcl.type.simple
 [defns.access]: intro.md#defns.access
 [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.comma.subscript]: future.md#depr.comma.subscript
 [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
@@ -553,26 +751,30 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.mptr.oper]: #expr.mptr.oper
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
 [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.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.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.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
@@ -587,10 +789,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [expr.throw]: #expr.throw
 [expr.type]: #expr.type
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
 [expr.yield]: #expr.yield
 [function.objects]: utilities.md#function.objects
@@ -602,35 +805,41 @@ A function or variable is *needed for constant evaluation* if it is:
 [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]: utilities.md#meta.const.eval
-[namespace.qual]: basic.md#namespace.qual
 [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.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
 [replacement.functions]: library.md#replacement.functions
 [special]: class.md#special
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.return]: stmt.md#stmt.return
 [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
@@ -638,17 +847,25 @@ A function or variable is *needed for constant evaluation* if it is:
 [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.names]: temp.md#temp.names
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [thread]: thread.md#thread
 [type.info]: support.md#type.info
 [^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
@@ -657,11 +874,11 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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 may or may not 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]].
@@ -675,23 +892,23 @@ A function or variable is *needed for constant evaluation* if it is:
     be obtained.
 [^8]: The rule for conversion of pointers to members (from pointer to
     member of base to pointer to member of derived) appears inverted
     compared to the rule for pointers to objects (from pointer to
-    derived to pointer to base) ([[conv.ptr]], [[class.derived]]). This
     inversion is necessary to ensure type safety. Note that a pointer to
     member is not an object pointer or a function pointer and the rules
     for conversions of such pointers do not apply to pointers to
     members. In particular, a pointer to member cannot be converted to a
     `void*`.
 [^9]: As a consequence, operands of type `bool`, `char8_t`, `char16_t`,
-    `char32_t`, `wchar_t`, or an enumerated 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
@@ -708,38 +925,37 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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 may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^18]: `T1` and `T2` may 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 may 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 may 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.
@@ -767,17 +983,19 @@ A function or variable is *needed for constant evaluation* if it is:
 [^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]: Nonetheless, implementations should provide consistent results,
-    irrespective of whether the evaluation was performed during
-    translation and/or during program execution.
-[^33]: Testing this condition may involve a trial evaluation of its
     initializer as described above.
-[^34]: Constant evaluation may be necessary to determine whether a
-    narrowing conversion is performed [[dcl.init.list]].
-[^35]: Constant evaluation may be necessary to determine whether such an
-    expression is value-dependent [[temp.dep.constexpr]].

   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
+constant expressions* at a point P if V’s initializing declaration D is
 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
 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
+  refers to a non-active member of a union or a subobject thereof;
 - an lvalue-to-rvalue conversion that is applied to an object with an
   indeterminate value [[basic.indet]];
 - an invocation of an implicitly-defined copy/move constructor or
   copy/move assignment operator for a union whose active member (if any)
   is mutable, unless the lifetime of the union object began within the
   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
     };
   }
   ```
   — *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()); };
   };
   — *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
   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) { }
   int m;
 };
+constexpr int v = A(true).m;        // OK, constructor call initializes m with the value 42
 constexpr int w = A(false).m;       // error: initializer for m is x, which is non-constant
 constexpr int f1(int k) {
   constexpr int x = k;              // error: x is not initialized by a constant expression
                                     // because lifetime of k began outside the initializer of x
   return x;
 }
 constexpr int f2(int k) {
+  int x = k;                        // OK, not required to be a constant expression
                                     // because x is not constexpr
   return x;
 }
 constexpr int incr(int &n) {
   constexpr int x = incr(k);        // error: incr(k) is not a core constant expression
                                     // because lifetime of k began outside the expression incr(k)
   return x;
 }
 constexpr int h(int k) {
+  int x = incr(k);                  // OK, incr(k) is not required to be a core constant expression
   return x;
 }
+constexpr int y = h(1);             // OK, initializes y with the value 2
                                     // h(1) is a core constant expression because
                                     // the lifetime of k begins inside h(1)
 ```
 — *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;
+}
+void use_array(int const (&gold_medal_mel)[2]) {
+  constexpr auto gold = array_size(gold_medal_mel);     // OK
+}
+constexpr auto olympic_mile() {
+  const int ledecky = 1500;
+  return []{ return ledecky; };
+}
+static_assert(olympic_mile()() == 1500);                // OK
+struct Swim {
+  constexpr int phelps() { return 28; }
+  virtual constexpr int lochte() { return 12; }
+  int coughlin = 12;
+};
+constexpr int how_many(Swim& swam) {
+  Swim* p = &swam;
+  return (p + 1 - 1)->phelps();
+}
+void splash(Swim& swam) {
+  static_assert(swam.phelps() == 28);           // OK
+  static_assert((&swam)->phelps() == 28);       // OK
+  Swim* pswam = &swam;
+  static_assert(pswam->phelps() == 28);         // error: lvalue-to-rvalue conversion on a pointer
+                                                // not usable in constant expressions
+  static_assert(how_many(swam) == 28);          // OK
+  static_assert(Swim().lochte() == 12);         // OK
+  static_assert(swam.lochte() == 12);           // error: invoking virtual function on reference
+                                                // with constexpr-unknown dynamic type
+  static_assert(swam.coughlin == 12);           // error: lvalue-to-rvalue conversion on an object
+                                                // not usable in constant expressions
+}
+extern Swim dc;
+extern Swim& trident;
+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; }
   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*]
 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
 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(); }
                                                 // 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
 — *end example*]
 — *end note*]
 An expression or conversion is in an *immediate function context* if it
+is potentially evaluated and either:
+- its innermost enclosing non-block scope is a function parameter scope
+ of an immediate function,
+- it is a subexpression of a manifestly constant-evaluated expression or
+  conversion, or
+- its enclosing statement is enclosed [[stmt.pre]] by the
+  *compound-statement* of a consteval if statement [[stmt.if]].
+An invocation is an *immediate invocation* if it is a
+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,
+- a defaulted special member function that is not declared with the
+  `consteval` specifier, or
+- a function that results from the instantiation of a templated entity
+  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; }
+template<class T>
+constexpr int f(T t) {
+  return t + id(t);
+}
+auto a = &f<char>;              // OK, f<char> is not an immediate function
+auto b = &f<int>;               // error: f<int> is an immediate function
+static_assert(f(3) == 6);       // OK
+template<class T>
+constexpr int g(T t) {          // g<int> is not an immediate function
+  return t + id(42);            // because id(42) is already a constant
+}
+template<class T, class F>
+constexpr bool is_not(T t, F f) {
+  return not f(t);
+}
+consteval bool is_even(int i) { return i % 2 == 0; }
+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
+struct A {
+  int x;
+  int y = id(x);
+};
+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:
 - a *constant-expression*, or
 - 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
   const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2
   int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to y+y
   constexpr int f() {
     const int n = std::is_constant_evaluated() ? 13 : 17; // n is 13
+    int m = std::is_constant_evaluated() ? 13 : 17;       // m can be 13 or 17 (see below)
     char arr[n] = {}; // char[13]
     return m + sizeof(arr);
   }
   int p = f();                                            // m is 13; initialized to 26
   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:
 - a constexpr function that is named by an expression [[basic.def.odr]]
   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.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.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
+[class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [cmp.categories]: support.md#cmp.categories
+[compare.syn]: support.md#compare.syn
 [conv]: #conv
 [conv.array]: #conv.array
 [conv.bool]: #conv.bool
 [conv.double]: #conv.double
 [conv.fctptr]: #conv.fctptr
 [conv.fpint]: #conv.fpint
 [conv.fpprom]: #conv.fpprom
 [conv.func]: #conv.func
+[conv.general]: #conv.general
 [conv.integral]: #conv.integral
 [conv.lval]: #conv.lval
 [conv.mem]: #conv.mem
 [conv.prom]: #conv.prom
 [conv.ptr]: #conv.ptr
 [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.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
 [expr.mptr.oper]: #expr.mptr.oper
 [expr.mul]: #expr.mul
 [expr.new]: #expr.new
 [expr.or]: #expr.or
 [expr.post]: #expr.post
+[expr.post.general]: #expr.post.general
 [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.throw]: #expr.throw
 [expr.type]: #expr.type
 [expr.type.conv]: #expr.type.conv
 [expr.typeid]: #expr.typeid
 [expr.unary]: #expr.unary
+[expr.unary.general]: #expr.unary.general
 [expr.unary.noexcept]: #expr.unary.noexcept
 [expr.unary.op]: #expr.unary.op
 [expr.xor]: #expr.xor
 [expr.yield]: #expr.yield
 [function.objects]: utilities.md#function.objects
 [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.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.
 [^2]: Overloaded operators are never assumed to be associative or
 [^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]].
     be obtained.
 [^8]: The rule for conversion of pointers to members (from pointer to
     member of base to pointer to member of derived) appears inverted
     compared to the rule for pointers to objects (from pointer to
+    derived to pointer to base) [[conv.ptr]], [[class.derived]]. This
     inversion is necessary to ensure type safety. Note that a pointer to
     member is not an object pointer or a function pointer and the rules
     for conversions of such pointers do not apply to pointers to
     members. In particular, a pointer to member cannot be converted to a
     `void*`.
 [^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
 [^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.
 [^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]].

Diff to HTML by rtfpessoa