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

Files changed (1) hide show

tmp/tmpj_pcwzvt/{from.md → to.md} +327 -264

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

@@ -11,12 +11,14 @@ postfix-expression:
     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
-    postfix-expression '.' 'template'ₒₚₜ id-expression
-    postfix-expression '->' 'template'ₒₚₜ id-expression
     postfix-expression '++'
     postfix-expression '--'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
@@ -39,23 +41,24 @@ replacing a `>>` token by two consecutive `>` tokens
 A *subscript expression* is a postfix expression followed by square
 brackets containing a possibly empty, comma-separated list of
 *initializer-clause*s that constitute the arguments to the subscript
 operator. The *postfix-expression* and the initialization of the object
-parameter of any applicable subscript operator function is sequenced
-before each expression in the *expression-list* and also before any
-default argument. The initialization of a non-object parameter of a
-subscript operator function `S` [[over.sub]], including every associated
-value computation and side effect, is indeterminately sequenced with
-respect to that of any other non-object parameter of `S`.
 With the built-in subscript operator, an *expression-list* shall be
 present, consisting of a single *assignment-expression*. One of the
 expressions shall be a glvalue of type “array of `T`” or a prvalue of
 type “pointer to `T`” and the other shall be a prvalue of unscoped
 enumeration or integral type. The result is of type “`T`”. The type
-“`T`” shall be a completely-defined object type.[^11]
 The expression `E1[E2]` is identical (by definition) to `*((E1)+(E2))`,
 except that in the case of an array operand, the result is an lvalue if
 that operand is an lvalue and an xvalue otherwise.
@@ -68,20 +71,20 @@ of array types. — *end note*]
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
-[*Note 1*: If the postfix expression is a function or member function
-name, the appropriate function and the validity of the call are
-determined according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
-function, the postfix expression shall either be an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
-[[conv.func]] is suppressed on the postfix expression), or have function
-pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
@@ -90,14 +93,13 @@ type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
-[*Note 3*: If a function or member function name is used, and name
-lookup [[basic.lookup]] does not find a declaration of that name, the
-program is ill-formed. No function is implicitly declared by such a
-call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
@@ -106,41 +108,44 @@ different. If the *postfix-expression* names a pseudo-destructor (in
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
-Calling a function through an expression whose function type `E` is
-different from the function type `F` of the called function’s definition
-results in undefined behavior unless the type “pointer to `F`” can be
-converted to the type “pointer to `E`” via a function pointer conversion
-[[conv.fctptr]].
-[*Note 4*: The exception applies when the expression has the type of a
-potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
-[[dcl.init]], [[class.copy.ctor]] with its corresponding argument. If
-the function is an explicit object member function and there is an
-implied object argument [[over.call.func]], the list of provided
-arguments is preceded by the implied object argument for the purposes of
-this correspondence. If there is no corresponding argument, the default
-argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
-If the function is an implicit object member function, the `this`
-parameter of the function [[expr.prim.this]] is initialized with a
-pointer to the object of the call, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
@@ -151,28 +156,37 @@ class type that is either incomplete or abstract.
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
-It is *implementation-defined* whether the lifetime of a parameter ends
-when the function in which it is defined returns or at the end of the
-enclosing full-expression. The initialization and destruction of each
-parameter occurs within the context of the calling function.
-[*Example 2*: The access of the constructor, conversion functions or
-destructor is checked at the point of call in the calling function. If a
-constructor or destructor for a function parameter throws an exception,
-the search for a handler starts in the calling function; in particular,
-if the function called has a *function-try-block* [[except.pre]] with a
-handler that can handle the exception, this handler is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
-parameter, including every associated value computation and side effect,
-is indeterminately sequenced with respect to that of any other
-parameter.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
@@ -216,17 +230,26 @@ control out of the called function (if any), except in a virtual
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
-reference is to a const-qualified type, `const_cast` is required to be
-used to cast away the constness in order to modify the argument’s value.
-Where a parameter is of `const` reference type a temporary object is
-introduced if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
@@ -252,15 +275,16 @@ The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
-potentially-evaluated argument of a scoped enumeration type or of a
-class type [[class]] having an eligible non-trivial copy constructor, an
-eligible non-trivial move constructor, or a non-trivial destructor
-[[special]], with no corresponding parameter, is conditionally-supported
-with *implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
@@ -268,11 +292,13 @@ referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
-type is an rvalue reference to object type, and a prvalue otherwise.
 #### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
 A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 [[temp.res]] followed by a parenthesized optional *expression-list* or
@@ -281,11 +307,28 @@ specified type given the initializer. If the type is a placeholder for a
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type, it is replaced by
 the type determined by placeholder type deduction
-[[dcl.type.auto.deduct]].
 [*Example 1*:
 ``` cpp
 struct A {};
@@ -299,44 +342,41 @@ void h() {
 }
 ```
 — *end example*]
-If the initializer is a parenthesized single expression, the type
-conversion expression is equivalent to the corresponding cast expression
-[[expr.cast]]. Otherwise, if the type is cv `void` and the initializer
-is `()` or `{}` (after pack expansion, if any), the expression is a
-prvalue of type `void` that performs no initialization. Otherwise, the
-expression is a prvalue of the specified type whose result object is
-direct-initialized [[dcl.init]] with the initializer. If the initializer
-is a parenthesized optional *expression-list*, the specified type shall
-not be an array type.
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 A postfix expression followed by a dot `.` or an arrow `->`, optionally
 followed by the keyword `template`, and then followed by an
-*id-expression*, is a postfix expression. The postfix expression before
-the dot or arrow is evaluated;[^12]
-the result of that evaluation, together with the *id-expression*,
-determines the result of the entire postfix expression.
-[*Note 1*: If the keyword `template` is used, the following unqualified
-name is considered to refer to a template [[temp.names]]. If a
-*simple-template-id* results and is followed by a `::`, the
-*id-expression* is a *qualified-id*. — *end note*]
-For the first option (dot) the first expression shall be a glvalue. For
-the second option (arrow) the first expression shall be a prvalue having
-pointer type. The expression `E1->E2` is converted to the equivalent
-form `(*(E1)).E2`; the remainder of [[expr.ref]] will address only the
-first option (dot).[^13]
-Abbreviating *postfix-expression*`.`*id-expression* as `E1.E2`, `E1` is
-called the *object expression*. If the object expression is of scalar
-type, `E2` shall name the pseudo-destructor of that same type (ignoring
 cv-qualifications) and `E1.E2` is a prvalue of type “function of ()
 returning `void`”.
 [*Note 2*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
@@ -349,68 +389,105 @@ definition of that class.
 when the class is complete [[class.member.lookup]]. — *end note*]
 [*Note 4*:  [[basic.lookup.qual]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
-If `E2` is a bit-field, `E1.E2` is a bit-field. The type and value
-category of `E1.E2` are determined as follows. In the remainder of
-[[expr.ref]], *cq* represents either `const` or the absence of `const`
-and *vq* represents either `volatile` or the absence of `volatile`. *cv*
-represents an arbitrary set of cv-qualifiers, as defined in
-[[basic.type.qualifier]].
-If `E2` is declared to have type “reference to `T`”, then `E1.E2` is an
-lvalue of type `T`. If `E2` is a static data member, `E1.E2` designates
-the object or function to which the reference is bound, otherwise
-`E1.E2` designates the object or function to which the corresponding
-reference member of `E1` is bound. Otherwise, one of the following rules
-applies.
-- If `E2` is a static data member and the type of `E2` is `T`, then
- `E1.E2` is an lvalue; the expression designates the named member of
-  the class. The type of `E1.E2` is `T`.
-- If `E2` is a non-static data member and the type of `E1` is “*cq1 vq1*
-  `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the expression
-  designates the corresponding member subobject of the object designated
-  by the first expression. If `E1` is an lvalue, then `E1.E2` is an
-  lvalue; otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand
- for the “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is
- `volatile`, then *vq12* is `volatile`. Similarly, let the notation
-  *cq12* stand for the “union” of *cq1* and *cq2*; that is, if *cq1* or
- *cq2* is `const`, then *cq12* is `const`. If `E2` is declared to be a
- `mutable` member, then the type of `E1.E2` is “*vq12* `T`”. If `E2` is
- not declared to be a `mutable` member, then the type of `E1.E2` is
- “*cq12* *vq12* `T`”.
-- If `E2` is an overload set, function overload resolution
- [[over.match]] is used to select the function to which `E2` refers.
- The type of `E1.E2` is the type of `E2` and `E1.E2` refers to the
- function referred to by `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
-    `E1.E2` is a prvalue. The expression can be used only as the
- left-hand operand of a member function call [[class.mfct]].
- \[*Note 5*: Any redundant set of parentheses surrounding the
-    expression is ignored [[expr.prim.paren]]. — *end note*]
-- If `E2` is a nested type, the expression `E1.E2` is ill-formed.
-- If `E2` is a member enumerator and the type of `E2` is `T`, the
-  expression `E1.E2` is a prvalue of type `T` whose value is the value
-  of the enumerator.
-If `E2` is a non-static member, the program is ill-formed if the class
-of which `E2` is directly a member is an ambiguous base
-[[class.member.lookup]] of the naming class [[class.access.base]] of
-`E2`.
-[*Note 6*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
-If `E2` is a non-static member and the result of `E1` is an object whose
-type is not similar [[conv.qual]] to the type of `E1`, the behavior is
-undefined.
-[*Example 1*:
 ``` cpp
 struct A { int i; };
 struct B { int j; };
 struct D : A, B {};
@@ -423,33 +500,32 @@ void f() {
 — *end example*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
-The value of a postfix `++` expression is the value of its operand.
 [*Note 1*: The value obtained is a copy of the original
 value. — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
 object type. An operand with volatile-qualified type is deprecated; see
 [[depr.volatile.type]]. The value of the operand object is modified
-[[defns.access]] by adding `1` to it. The value computation of the `++`
-expression is sequenced before the modification of the operand object.
-With respect to an indeterminately-sequenced function call, the
-operation of postfix `++` is a single evaluation.
 [*Note 2*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single postfix `++` operator. — *end note*]
 The result is a prvalue. The type of the result is the cv-unqualified
-version of the type of the operand. If the operand is a bit-field that
-cannot represent the incremented value, the resulting value of the
-bit-field is *implementation-defined*. See also  [[expr.add]] and
-[[expr.ass]].
 The operand of postfix `--` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
@@ -477,11 +553,11 @@ If `T` is “pointer to *cv1* `B`” and `v` has type “pointer to *cv2* `D`”
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
-object referred to by `v`.[^14]
 In both the pointer and reference cases, the program is ill-formed if
 `B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
@@ -499,10 +575,18 @@ void foo(D* dp) {
 Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
 [[class.virtual]].
 If `v` is a null pointer value, the result is a null pointer value.
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
@@ -510,11 +594,11 @@ Let `C` be the class type to which `T` points or refers. The runtime
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
-  (referred) to by `v` the result points (refers) to that `C` object.
 - Otherwise, if `v` points (refers) to a public base class subobject of
   the most derived object, and the type of the most derived object has a
   base class, of type `C`, that is unambiguous and public, the result
   points (refers) to the `C` subobject of the most derived object.
 - Otherwise, the runtime check *fails*.
@@ -560,31 +644,35 @@ destruction. — *end note*]
 #### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
-or `const` *name* where *name* is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
-described in  [[type.info]].[^15]
 The lifetime of the object referred to by the lvalue extends to the end
 of the program. Whether or not the destructor is called for the
 `std::type_info` object at the end of the program is unspecified.
 If the type of the *expression* or *type-id* operand is a (possibly
 cv-qualified) class type or a reference to (possibly cv-qualified) class
 type, that class shall be completely defined.
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
-is, the dynamic type) to which the glvalue refers. If the glvalue is
-obtained by applying the unary `*` operator to a pointer[^16]
-and the pointer is a null pointer value [[basic.compound]], the `typeid`
-expression throws an exception [[except.throw]] of a type that would
-match a handler of type `std::bad_typeid` exception [[bad.typeid]].
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
@@ -597,11 +685,11 @@ When `typeid` is applied to a *type-id*, the result refers to a
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
 object representing the cv-unqualified referenced type.
-[*Note 1*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
@@ -624,24 +712,23 @@ typeid(D)  == typeid(const D&); // yields true
 The type `std::type_info` [[type.info]] is not predefined; if a standard
 library declaration [[typeinfo.syn]], [[std.modules]] of
 `std::type_info` does not precede [[basic.lookup.general]] a `typeid`
 expression, the program is ill-formed.
-[*Note 2*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
-otherwise, the result is a prvalue. The `static_cast` operator shall not
-cast away constness [[expr.const.cast]].
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
-type “reference to *cv2* `D`”, where `D` is a class derived
 [[class.derived]] from `B`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*. If `B` is a virtual base class of
 `D` or a base class of a virtual base class of `D`, or if no valid
 standard conversion from “pointer to `D`” to “pointer to `B`” exists
 [[conv.ptr]], the program is ill-formed. An xvalue of type “*cv1* `B`”
@@ -672,14 +759,25 @@ class subobject thereof; otherwise, the lvalue-to-rvalue conversion
 used as the operand of the `static_cast` for the remainder of this
 subclause. If `T2` is an inaccessible [[class.access]] or ambiguous
 [[class.member.lookup]] base class of `T1`, a program that necessitates
 such a cast is ill-formed.
-An expression E can be explicitly converted to a type `T` if there is an
-implicit conversion sequence [[over.best.ics]] from E to `T`, if
-overload resolution for a direct-initialization [[dcl.init]] of an
-object or reference of type `T` from E would find at least one viable
 function [[over.match.viable]], or if `T` is an aggregate type
 [[dcl.init.aggr]] having a first element `x` and there is an implicit
 conversion sequence from E to the type of `x`. If `T` is a reference
 type, the effect is the same as performing the declaration and
 initialization
@@ -690,59 +788,23 @@ T t(E);
 for some invented temporary variable `t` [[dcl.init]] and then using the
 temporary variable as the result of the conversion. Otherwise, the
 result object is direct-initialized from E.
-[*Note 1*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
-[*Note 2*: If `T` is “array of unknown bound of `U`”, this
 direct-initialization defines the type of the expression as
 `U[1]`. — *end note*]
-Otherwise, the `static_cast` shall perform one of the conversions listed
-below. No other conversion shall be performed explicitly using a
-`static_cast`.
-Any expression can be explicitly converted to type cv `void`, in which
-case the operand is a discarded-value expression [[expr.prop]].
-[*Note 3*: Such a `static_cast` has no result as it is a prvalue of
-type `void`; see  [[basic.lval]]. — *end note*]
-[*Note 4*: However, if the value is in a temporary object
-[[class.temporary]], the destructor for that object is not executed
-until the usual time, and the value of the object is preserved for the
-purpose of executing the destructor. — *end note*]
-The inverse of any standard conversion sequence [[conv]] not containing
-an lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]],
-function-to-pointer [[conv.func]], null pointer [[conv.ptr]], null
-member pointer [[conv.mem]], boolean [[conv.bool]], or function pointer
-[[conv.fctptr]] conversion, can be performed explicitly using
-`static_cast`. A program is ill-formed if it uses `static_cast` to
-perform the inverse of an ill-formed standard conversion sequence.
-[*Example 2*:
-``` cpp
-struct B { };
-struct D : private B { };
-void f() {
-  static_cast<D*>((B*)0);               // error: B is a private base of D
-  static_cast<int B::*>((int D::*)0);   // error: B is a private base of D
-}
-```
-— *end example*]
-The lvalue-to-rvalue [[conv.lval]], array-to-pointer [[conv.array]], and
-function-to-pointer [[conv.func]] conversions are applied to the
-operand. Such a `static_cast` is subject to the restriction that the
-explicit conversion does not cast away constness [[expr.const.cast]],
-and the following additional rules for specific cases:
 A value of a scoped enumeration type [[dcl.enum]] can be explicitly
 converted to an integral type; the result is the same as that of
 converting to the enumeration’s underlying type and then to the
 destination type. A value of a scoped enumeration type can also be
@@ -795,14 +857,13 @@ pointer-to-member-function types) are never cv-qualified
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
 program is ill-formed. The null member pointer value [[conv.mem]] is
 converted to the null member pointer value of the destination type. If
-class `B` contains the original member, or is a base or derived class of
-the class containing the original member, the resulting pointer to
-member points to the original member. Otherwise, the behavior is
-undefined.
 [*Note 6*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
@@ -810,17 +871,18 @@ member is performed must contain the original member; see
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
-`T`, then the resulting pointer value is unspecified. Otherwise, if the
-original pointer value points to an object *a*, and there is an object
-*b* of type similar to `T` that is pointer-interconvertible
-[[basic.compound]] with *a*, the result is a pointer to *b*. Otherwise,
-the pointer value is unchanged by the conversion.
-[*Example 3*:
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
@@ -865,12 +927,12 @@ the conversion has the same meaning and validity as a conversion of
 any type to the type `std::nullptr_t`. — *end note*]
 A value of integral type or enumeration type can be explicitly converted
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
-will have its original value; mappings between pointers and integers are
-otherwise *implementation-defined*.
 A function pointer can be explicitly converted to a function pointer of
 a different type.
 [*Note 4*: The effect of calling a function through a pointer to a
@@ -880,21 +942,18 @@ definition of the function is undefined [[expr.call]]. — *end note*]
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
-[*Note 5*: See also  [[conv.ptr]] for more details of pointer
-conversions. — *end note*]
 An object pointer can be explicitly converted to an object pointer of a
-different type.[^17]
 When a prvalue `v` of object pointer type is converted to the object
 pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
-[*Note 6*: Converting a pointer of type “pointer to `T1`” that points
 to an object of type `T1` to the type “pointer to `T2`” (where `T2` is
 an object type and the alignment requirements of `T2` are no stricter
 than those of `T1`) and back to its original type yields the original
 pointer value. — *end note*]
@@ -906,19 +965,19 @@ other type and back, possibly with different cv-qualification, shall
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
-[*Note 7*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
-object types.[^18]
 The null member pointer value [[conv.mem]] is converted to the null
 member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
@@ -929,79 +988,83 @@ conversion is unspecified, except in the following cases:
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
   and back to its original type yields the original pointer-to-member
   value.
-A glvalue of type `T1`, designating an object *x*, can be cast to the
-type “reference to `T2`” if an expression of type “pointer to `T1`” can
-be explicitly converted to the type “pointer to `T2`” using a
-`reinterpret_cast`. The result is that of `*reinterpret_cast<T2 *>(p)`
-where `p` is a pointer to *x* of type “pointer to `T1`”. No temporary is
-created, no copy is made, and no constructors [[class.ctor]] or
-conversion functions [[class.conv]] are called.[^19]
 #### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] standard conversions are performed on the expression `v`.
-Conversions that can be performed explicitly using `const_cast` are
-listed below. No other conversion shall be performed explicitly using
-`const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
 can be cast to its own type using a `const_cast`
 operator. — *end note*]
-For two similar types `T1` and `T2` [[conv.qual]], a prvalue of type
-`T1` may be explicitly converted to the type `T2` using a `const_cast`
-if, considering the qualification-decompositions of both types, each P¹ᵢ
-is the same as P²ᵢ for all i. The result of a `const_cast` refers to the
-original entity.
-[*Example 1*:
-``` cpp
-typedef int *A[3];                  // array of 3 pointer to int
-typedef const int *const CA[3];     // array of 3 const pointer to const int
-CA &&r = A{};                       // OK, reference binds to temporary array object
-                                    // after qualification conversion to type CA
-A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
-A &&r2 = const_cast<A&&>(CA{});     // OK
-```
-— *end example*]
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
 - an lvalue of type `T1` can be explicitly converted to an lvalue of
   type `T2` using the cast `const_cast<T2&>`;
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
-- if `T1` is a class type, a prvalue of type `T1` can be explicitly
-  converted to an xvalue of type `T2` using the cast `const_cast<T2&&>`.
-The result of a reference `const_cast` refers to the original object if
-the operand is a glvalue and to the result of applying the temporary
-materialization conversion [[conv.rval]] otherwise.
-A null pointer value [[basic.compound]] is converted to the null pointer
-value of the destination type. The null member pointer value
-[[conv.mem]] is converted to the null member pointer value of the
-destination type.
 [*Note 2*:
 Depending on the type of the object, a write operation through the
 pointer, lvalue or pointer to data member resulting from a `const_cast`
-that casts away a const-qualifier[^20]
 can produce undefined behavior [[dcl.type.cv]].
 — *end note*]

     postfix-expression '(' expression-listₒₚₜ ')'
     simple-type-specifier '(' expression-listₒₚₜ ')'
     typename-specifier '(' expression-listₒₚₜ ')'
     simple-type-specifier braced-init-list
     typename-specifier braced-init-list
+    postfix-expression '.' templateₒₚₜ id-expression
+    postfix-expression '.' splice-expression
+    postfix-expression '->' templateₒₚₜ id-expression
+    postfix-expression '->' splice-expression
     postfix-expression '++'
     postfix-expression '--'
     dynamic_cast '<' type-id '>' '(' expression ')'
     static_cast '<' type-id '>' '(' expression ')'
     reinterpret_cast '<' type-id '>' '(' expression ')'
 A *subscript expression* is a postfix expression followed by square
 brackets containing a possibly empty, comma-separated list of
 *initializer-clause*s that constitute the arguments to the subscript
 operator. The *postfix-expression* and the initialization of the object
+parameter [[dcl.fct]] of any applicable subscript operator function
+[[over.sub]] is sequenced before each expression in the
+*expression-list* and also before any default argument
+[[dcl.fct.default]]. The initialization of a non-object parameter of a
+subscript operator function `S`, including every associated value
+computation and side effect, is indeterminately sequenced with respect
+to that of any other non-object parameter of `S`.
 With the built-in subscript operator, an *expression-list* shall be
 present, consisting of a single *assignment-expression*. One of the
 expressions shall be a glvalue of type “array of `T`” or a prvalue of
 type “pointer to `T`” and the other shall be a prvalue of unscoped
 enumeration or integral type. The result is of type “`T`”. The type
+“`T`” shall be a completely-defined object type.[^10]
 The expression `E1[E2]` is identical (by definition) to `*((E1)+(E2))`,
 except that in the case of an array operand, the result is an lvalue if
 that operand is an lvalue and an xvalue otherwise.
 A function call is a postfix expression followed by parentheses
 containing a possibly empty, comma-separated list of
 *initializer-clause*s which constitute the arguments to the function.
+[*Note 1*: If the postfix expression is a function name, the
+appropriate function and the validity of the call are determined
+according to the rules in  [[over.match]]. — *end note*]
 The postfix expression shall have function type or function pointer
 type. For a call to a non-member function or to a static member
+function, the postfix expression shall be either an lvalue that refers
 to a function (in which case the function-to-pointer standard conversion
+[[conv.func]] is suppressed on the postfix expression), or a prvalue of
+function pointer type.
 If the selected function is non-virtual, or if the *id-expression* in
 the class member access expression is a *qualified-id*, that function is
 called. Otherwise, its final overrider [[class.virtual]] in the dynamic
 type of the object expression is called; such a call is referred to as a
 [*Note 2*: The dynamic type is the type of the object referred to by
 the current value of the object expression. [[class.cdtor]] describes
 the behavior of virtual function calls when the object expression refers
 to an object under construction or destruction. — *end note*]
+[*Note 3*: If a function name is used, and name lookup [[basic.lookup]]
+does not find a declaration of that name, the program is ill-formed. No
+function is implicitly declared by such a call. — *end note*]
 If the *postfix-expression* names a destructor or pseudo-destructor
 [[expr.prim.id.dtor]], the type of the function call expression is
 `void`; otherwise, the type of the function call expression is the
 return type of the statically chosen function (i.e., ignoring the
 which case the *postfix-expression* is a possibly-parenthesized class
 member access), the function call destroys the object of scalar type
 denoted by the object expression of the class member access
 [[expr.ref]], [[basic.life]].
+A type `T`_call is *call-compatible* with a function type `T`_func if
+`T`_call is the same type as `T`_func or if the type “pointer to
+`T`_func” can be converted to type “pointer to `T`_call” via a function
+pointer conversion [[conv.fctptr]]. Calling a function through an
+expression whose function type is not call-compatible with the type of
+the called function’s definition results in undefined behavior.
+[*Note 4*: This requirement allows the case when the expression has the
+type of a potentially-throwing function, but the called function has a
 non-throwing exception specification, and the function types are
 otherwise the same. — *end note*]
 When a function is called, each parameter [[dcl.fct]] is initialized
+[[dcl.init]], [[class.copy.ctor]] with its corresponding argument, and
+each precondition assertion of the function is evaluated
+[[dcl.contract.func]]. If the function is an explicit object member
+function and there is an implied object argument [[over.call.func]], the
+list of provided arguments is preceded by the implied object argument
+for the purposes of this correspondence. If there is no corresponding
+argument, the default argument for the parameter is used.
 [*Example 1*:
 ``` cpp
 template<typename ...T> int f(int n = 0, T ...t);
 int x = f<int>();               // error: no argument for second function parameter
 ```
 — *end example*]
+If the function is an implicit object member function, the object
+expression of the class member access shall be a glvalue and the
+implicit object parameter of the function [[over.match.funcs]] is
+initialized with that glvalue, converted as if by an explicit type
 conversion [[expr.cast]].
 [*Note 5*: There is no access or ambiguity checking on this conversion;
 the access checking and disambiguation are done as part of the (possibly
 implicit) class member access operator. See  [[class.member.lookup]],
 [*Note 6*: This still allows a parameter to be a pointer or reference
 to such a type. However, it prevents a passed-by-value parameter to have
 an incomplete or abstract class type. — *end note*]
+It is *implementation-defined* whether a parameter is destroyed when the
+function in which it is defined exits
+[[stmt.return]], [[except.ctor]], [[expr.await]] or at the end of the
+enclosing full-expression; parameters are always destroyed in the
+reverse order of their construction. The initialization and destruction
+of each parameter occurs within the context of the full-expression
+[[intro.execution]] where the function call appears.
+[*Example 2*: The access [[class.access.general]] of the constructor,
+conversion functions, or destructor is checked at the point of call. If
+a constructor or destructor for a function parameter throws an
+exception, any *function-try-block* [[except.pre]] of the called
+function with a handler that can handle the exception is not
 considered. — *end example*]
 The *postfix-expression* is sequenced before each *expression* in the
 *expression-list* and any default argument. The initialization of a
+parameter or, if the implementation introduces any temporary objects to
+hold the values of function parameters [[class.temporary]], the
+initialization of those temporaries, including every associated value
+computation and side effect, is indeterminately sequenced with respect
+to that of any other parameter. These evaluations are sequenced before
+the evaluation of the precondition assertions of the function, which are
+evaluated in sequence [[dcl.contract.func]]. For any temporaries
+introduced to hold the values of function parameters, the initialization
+of the parameter objects from those temporaries is indeterminately
+sequenced with respect to the evaluation of each precondition assertion.
 [*Note 7*: All side effects of argument evaluations are sequenced
 before the function is entered (see
 [[intro.execution]]). — *end note*]
 function call if the return type of the final overrider is different
 from the return type of the statically chosen function, the value
 returned from the final overrider is converted to the return type of the
 statically chosen function.
+When the called function exits normally [[stmt.return]], [[expr.await]],
+all postcondition assertions of the function are evaluated in sequence
+[[dcl.contract.func]]. If the implementation introduces any temporary
+objects to hold the result value as specified in [[class.temporary]],
+the evaluation of each postcondition assertion is indeterminately
+sequenced with respect to the initialization of any of those temporaries
+or the result object. These evaluations, in turn, are sequenced before
+the destruction of any function parameters.
 [*Note 9*:  A function can change the values of its non-const
 parameters, but these changes cannot affect the values of the arguments
 except where a parameter is of a reference type [[dcl.ref]]; if the
+reference is to a const-qualified type, `const_cast` needs to be used to
+cast away the constness in order to modify the argument’s value. Where a
+parameter is of `const` reference type a temporary object is introduced
+if needed
 [[dcl.type]], [[lex.literal]], [[lex.string]], [[dcl.array]], [[class.temporary]].
 In addition, it is possible to modify the values of non-constant objects
 through pointer parameters. — *end note*]
 A function can be declared to accept fewer arguments (by declaring
 function-to-pointer [[conv.func]] standard conversions are performed on
 the argument expression. An argument that has type cv `std::nullptr_t`
 is converted to type `void*` [[conv.ptr]]. After these conversions, if
 the argument does not have arithmetic, enumeration, pointer,
 pointer-to-member, or class type, the program is ill-formed. Passing a
+potentially-evaluated argument of a scoped enumeration type [[dcl.enum]]
+or of a class type [[class]] having an eligible non-trivial copy
+constructor [[special]], [[class.copy.ctor]], an eligible non-trivial
+move constructor, or a non-trivial destructor [[class.dtor]], with no
+corresponding parameter, is conditionally-supported with
+*implementation-defined* semantics. If the argument has integral or
 enumeration type that is subject to the integral promotions
 [[conv.prom]], or a floating-point type that is subject to the
 floating-point promotion [[conv.fpprom]], the value of the argument is
 converted to the promoted type before the call. These promotions are
 referred to as the *default argument promotions*.
 Recursive calls are permitted, except to the `main` function
 [[basic.start.main]].
 A function call is an lvalue if the result type is an lvalue reference
 type or an rvalue reference to function type, an xvalue if the result
+type is an rvalue reference to object type, and a prvalue otherwise. If
+it is a non-void prvalue, the type of the function call expression shall
+be complete, except as specified in [[dcl.type.decltype]].
 #### Explicit type conversion (functional notation) <a id="expr.type.conv">[[expr.type.conv]]</a>
 A *simple-type-specifier* [[dcl.type.simple]] or *typename-specifier*
 [[temp.res]] followed by a parenthesized optional *expression-list* or
 deduced class type, it is replaced by the return type of the function
 selected by overload resolution for class template deduction
 [[over.match.class.deduct]] for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type, it is replaced by
 the type determined by placeholder type deduction
+[[dcl.type.auto.deduct]]. Let `T` denote the resulting type. Then:
+- If the initializer is a parenthesized single expression, the type
+  conversion expression is equivalent to the corresponding cast
+  expression [[expr.cast]].
+- Otherwise, if `T` is cv `void`, the initializer shall be `()` or `{}`
+  (after pack expansion, if any), and the expression is a prvalue of
+  type `void` that performs no initialization.
+- Otherwise, if `T` is a reference type, the expression has the same
+  effect as direct-initializing an invented variable `t` of type `T`
+  from the initializer and then using `t` as the result of the
+  expression; the result is an lvalue if `T` is an lvalue reference type
+  or an rvalue reference to function type and an xvalue otherwise.
+- Otherwise, the expression is a prvalue of type `T` whose result object
+  is direct-initialized [[dcl.init]] with the initializer.
+If the initializer is a parenthesized optional *expression-list*, `T`
+shall not be an array type.
 [*Example 1*:
 ``` cpp
 struct A {};
 }
 ```
 — *end example*]
 #### Class member access <a id="expr.ref">[[expr.ref]]</a>
 A postfix expression followed by a dot `.` or an arrow `->`, optionally
 followed by the keyword `template`, and then followed by an
+*id-expression* or a *splice-expression*, is a postfix expression.
+[*Note 1*: If the keyword `template` is used and followed by an
+*id-expression*, the unqualified name is considered to refer to a
+template [[temp.names]]. If a *simple-template-id* results and is
+followed by a `::`, the *id-expression* is a
+*qualified-id*. — *end note*]
+For a dot that is followed by an expression that designates a static
+member or an enumerator, the first expression is a discarded-value
+expression [[expr.context]]; if the expression after the dot designates
+a non-static data member, the first expression shall be a glvalue. A
+postfix expression that is followed by an arrow shall be a prvalue
+having pointer type. The expression `E1->E2` is converted to the
+equivalent form `(*(E1)).E2`; the remainder of [[expr.ref]] will address
+only the form using a dot.[^11]
+The postfix expression before the dot is evaluated;[^12]
+the result of that evaluation, together with the *id-expression* or
+*splice-expression*, determines the result of the entire postfix
+expression.
+Abbreviating *postfix-expression*`.`*id-expression* or
+*postfix-expression*`.`*splice-expression* as `E1.E2`, `E1` is called
+the *object expression*. If the object expression is of scalar type,
+`E2` shall name the pseudo-destructor of that same type (ignoring
 cv-qualifications) and `E1.E2` is a prvalue of type “function of ()
 returning `void`”.
 [*Note 2*: This value can only be used for a notional function call
 [[expr.prim.id.dtor]]. — *end note*]
 when the class is complete [[class.member.lookup]]. — *end note*]
 [*Note 4*:  [[basic.lookup.qual]] describes how names are looked up
 after the `.` and `->` operators. — *end note*]
+If `E2` is a *splice-expression*, then let `T1` be the type of `E1`.
+`E2` shall designate either a member of `T1` or a direct base class
+relationship (`T1`, `B`).
+If `E2` designates a bit-field, `E1.E2` is a bit-field. The type and
+value category of `E1.E2` are determined as follows. In the remainder
+of  [[expr.ref]], *cq* represents either `const` or the absence of
+`const` and *vq* represents either `volatile` or the absence of
+`volatile`. *cv* represents an arbitrary set of cv-qualifiers, as
+defined in  [[basic.type.qualifier]].
+If `E2` designates an entity that is declared to have type “reference to
+`T`”, then `E1.E2` is an lvalue of type `T`. In that case, if `E2`
+designates a static data member, `E1.E2` designates the object or
+function to which the reference is bound, otherwise `E1.E2` designates
+the object or function to which the corresponding reference member of
+`E1` is bound. Otherwise, one of the following rules applies.
+- If `E2` designates a static data member and the type of `E2` is `T`,
+ then `E1.E2` is an lvalue; the expression designates the named member
+ of the class. The type of `E1.E2` is `T`.
+- Otherwise, if `E2` designates a non-static data member and the type of
+  `E1` is “*cq1 vq1* `X`”, and the type of `E2` is “*cq2 vq2* `T`”, the
+ expression designates the corresponding member subobject of the object
+ designated by `E1`. If `E1` is an lvalue, then `E1.E2` is an lvalue;
+ otherwise `E1.E2` is an xvalue. Let the notation *vq12* stand for the
+  “union” of *vq1* and *vq2*; that is, if *vq1* or *vq2* is `volatile`,
+ then *vq12* is `volatile`. Similarly, let the notation *cq12* stand
+ for the “union” of *cq1* and *cq2*; that is, if *cq1* or *cq2* is
+ `const`, then *cq12* is `const`. If the entity designated by `E2` is
+  declared to be a `mutable` member, then the type of `E1.E2` is “*vq12*
+  `T`”. If the entity designated by `E2` is not declared to be a
+  `mutable` member, then the type of `E1.E2` is “*cq12* *vq12* `T`”.
+- Otherwise, if `E2` denotes an overload set, the expression shall be
+  the (possibly-parenthesized) left-hand operand of a member function
+  call [[expr.call]], and function overload resolution [[over.match]] is
+  used to select the function to which `E2` refers. The type of `E1.E2`
+  is the type of `E2` and `E1.E2` refers to the function referred to by
+  `E2`.
   - If `E2` refers to a static member function, `E1.E2` is an lvalue.
   - Otherwise (when `E2` refers to a non-static member function),
+    `E1.E2` is a prvalue. \[*Note 5*: Any redundant set of parentheses
+ surrounding the expression is ignored
+    [[expr.prim.paren]]. — *end note*]
+- Otherwise, if `E2` designates a nested type, the expression `E1.E2` is
+ ill-formed.
+- Otherwise, if `E2` designates a member enumerator and the type of `E2`
+ is `T`, the expression `E1.E2` is a prvalue of type `T` whose value is
+ the value of the enumerator.
+- Otherwise, if `E2` designates a direct base class relationship (D, B)
+  and the type of `E1` is cv `T`, the expression designates the direct
+  base class subobject of type B of the object designated by `E1`. If
+  `E1` is an lvalue, then `E1.E2` is an lvalue; otherwise, `E1.E2` is an
+  xvalue. The type of `E1.E2` is “cv `B`”.
+  \[*Note 6*: This can only occur in an expression of the form
+  `e1.[:e2:]`. — *end note*]
+  \[*Example 1*:
+  ``` cpp
+  struct B {
+    int b;
+  };
+  struct C : B {
+    int get() const { return b; }
+  };
+  struct D : B, C { };
+  constexpr int f() {
+    D d = {1, {}};
+    // b unambiguously refers to the direct base class of type B,
+    // not the indirect base class of type B
+    B& b = d.[: std::meta::bases_of(^^D, std::meta::access_context::current())[0] :];
+    b.b += 10;
+    return 10 * b.b + d.get();
+  }
+  static_assert(f() == 110);
+  ```
+  — *end example*]
+- Otherwise, the program is ill-formed.
+If `E2` designates a non-static member (possibly after overload
+resolution), the program is ill-formed if the class of which `E2`
+designates a direct member is an ambiguous base [[class.member.lookup]]
+of the designating class [[class.access.base]] of `E2`.
+[*Note 7*: The program is also ill-formed if the naming class is an
 ambiguous base of the class type of the object expression; see
 [[class.access.base]]. — *end note*]
+If `E2` designates a non-static member (possibly after overload
+resolution) and the result of `E1` is an object whose type is not
+similar [[conv.qual]] to the type of `E1`, the behavior is undefined.
+[*Example 2*:
 ``` cpp
 struct A { int i; };
 struct B { int j; };
 struct D : A, B {};
 — *end example*]
 #### Increment and decrement <a id="expr.post.incr">[[expr.post.incr]]</a>
+The value of a postfix `++` expression is the value obtained by applying
+the lvalue-to-rvalue conversion [[conv.lval]] to its operand.
 [*Note 1*: The value obtained is a copy of the original
 value. — *end note*]
 The operand shall be a modifiable lvalue. The type of the operand shall
 be an arithmetic type other than cv `bool`, or a pointer to a complete
 object type. An operand with volatile-qualified type is deprecated; see
 [[depr.volatile.type]]. The value of the operand object is modified
+[[defns.access]] as if it were the operand of the prefix `++` operator
+[[expr.pre.incr]]. The value computation of the `++` expression is
+sequenced before the modification of the operand object. With respect to
+an indeterminately-sequenced function call, the operation of postfix
+`++` is a single evaluation.
 [*Note 2*: Therefore, a function call cannot intervene between the
 lvalue-to-rvalue conversion and the side effect associated with any
 single postfix `++` operator. — *end note*]
 The result is a prvalue. The type of the result is the cv-unqualified
+version of the type of the operand.
 The operand of postfix `--` is decremented analogously to the postfix
 `++` operator.
 [*Note 3*: For prefix increment and decrement, see
 such that `B` is a base class of `D`, the result is a pointer to the
 unique `B` subobject of the `D` object pointed to by `v`, or a null
 pointer value if `v` is a null pointer value. Similarly, if `T` is
 “reference to *cv1* `B`” and `v` has type *cv2* `D` such that `B` is a
 base class of `D`, the result is the unique `B` subobject of the `D`
+object referred to by `v`.[^13]
 In both the pointer and reference cases, the program is ill-formed if
 `B` is an inaccessible or ambiguous base class of `D`.
 [*Example 1*:
 Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic type
 [[class.virtual]].
 If `v` is a null pointer value, the result is a null pointer value.
+If `v` has type “pointer to cv `U`” and `v` does not point to an object
+whose type is similar [[conv.qual]] to `U` and that is within its
+lifetime or within its period of construction or destruction
+[[class.cdtor]], the behavior is undefined. If `v` is a glvalue of type
+`U` and `v` does not refer to an object whose type is similar to `U` and
+that is within its lifetime or within its period of construction or
+destruction, the behavior is undefined.
 If `T` is “pointer to cv `void`”, then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a runtime check is
 applied to see if the object pointed or referred to by `v` can be
 converted to the type pointed or referred to by `T`.
 check logically executes as follows:
 - If, in the most derived object pointed (referred) to by `v`, `v`
   points (refers) to a public base class subobject of a `C` object, and
   if only one object of type `C` is derived from the subobject pointed
+  (referred) to by `v`, the result points (refers) to that `C` object.
 - Otherwise, if `v` points (refers) to a public base class subobject of
   the most derived object, and the type of the most derived object has a
   base class, of type `C`, that is unambiguous and public, the result
   points (refers) to the `C` subobject of the most derived object.
 - Otherwise, the runtime check *fails*.
 #### Type identification <a id="expr.typeid">[[expr.typeid]]</a>
 The result of a `typeid` expression is an lvalue of static type `const`
 `std::type_info` [[type.info]] and dynamic type `const` `std::type_info`
+or `const` `name` where `name` is an *implementation-defined* class
 publicly derived from `std::type_info` which preserves the behavior
+described in  [[type.info]].[^14]
 The lifetime of the object referred to by the lvalue extends to the end
 of the program. Whether or not the destructor is called for the
 `std::type_info` object at the end of the program is unspecified.
 If the type of the *expression* or *type-id* operand is a (possibly
 cv-qualified) class type or a reference to (possibly cv-qualified) class
 type, that class shall be completely defined.
+If an *expression* operand of `typeid` is a possibly-parenthesized
+*unary-expression* whose *unary-operator* is `*` and whose operand
+evaluates to a null pointer value [[basic.compound]], the `typeid`
+expression throws an exception [[except.throw]] of a type that would
+match a handler of type `std::bad_typeid` [[bad.typeid]].
+[*Note 1*: In other contexts, evaluating such a *unary-expression*
+results in undefined behavior [[expr.unary.op]]. — *end note*]
 When `typeid` is applied to a glvalue whose type is a polymorphic class
 type [[class.virtual]], the result refers to a `std::type_info` object
 representing the type of the most derived object [[intro.object]] (that
+is, the dynamic type) to which the glvalue refers.
 When `typeid` is applied to an expression other than a glvalue of a
 polymorphic class type, the result refers to a `std::type_info` object
 representing the static type of the expression. Lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 `std::type_info` object representing the type of the *type-id*. If the
 type of the *type-id* is a reference to a possibly cv-qualified type,
 the result of the `typeid` expression refers to a `std::type_info`
 object representing the cv-unqualified referenced type.
+[*Note 2*: The *type-id* cannot denote a function type with a
 *cv-qualifier-seq* or a *ref-qualifier* [[dcl.fct]]. — *end note*]
 If the type of the expression or *type-id* is a cv-qualified type, the
 result of the `typeid` expression refers to a `std::type_info` object
 representing the cv-unqualified type.
 The type `std::type_info` [[type.info]] is not predefined; if a standard
 library declaration [[typeinfo.syn]], [[std.modules]] of
 `std::type_info` does not precede [[basic.lookup.general]] a `typeid`
 expression, the program is ill-formed.
+[*Note 3*: Subclause [[class.cdtor]] describes the behavior of `typeid`
 applied to an object under construction or destruction. — *end note*]
 #### Static cast <a id="expr.static.cast">[[expr.static.cast]]</a>
 The result of the expression `static_cast<T>(v)` is the result of
 converting the expression `v` to type `T`. If `T` is an lvalue reference
 type or an rvalue reference to function type, the result is an lvalue;
 if `T` is an rvalue reference to object type, the result is an xvalue;
+otherwise, the result is a prvalue.
 An lvalue of type “*cv1* `B`”, where `B` is a class type, can be cast to
+type “reference to *cv2* `D`”, where `D` is a complete class derived
 [[class.derived]] from `B`, if *cv2* is the same cv-qualification as, or
 greater cv-qualification than, *cv1*. If `B` is a virtual base class of
 `D` or a base class of a virtual base class of `D`, or if no valid
 standard conversion from “pointer to `D`” to “pointer to `B`” exists
 [[conv.ptr]], the program is ill-formed. An xvalue of type “*cv1* `B`”
 used as the operand of the `static_cast` for the remainder of this
 subclause. If `T2` is an inaccessible [[class.access]] or ambiguous
 [[class.member.lookup]] base class of `T1`, a program that necessitates
 such a cast is ill-formed.
+Any expression can be explicitly converted to type cv `void`, in which
+case the operand is a discarded-value expression [[expr.prop]].
+[*Note 1*: Such a `static_cast` has no result as it is a prvalue of
+type `void`; see  [[basic.lval]]. — *end note*]
+[*Note 2*: However, if the value is in a temporary object
+[[class.temporary]], the destructor for that object is not executed
+until the usual time, and the value of the object is preserved for the
+purpose of executing the destructor. — *end note*]
+Otherwise, an expression E can be explicitly converted to a type `T` if
+there is an implicit conversion sequence [[over.best.ics]] from E to
+`T`, if overload resolution for a direct-initialization [[dcl.init]] of
+an object or reference of type `T` from E would find at least one viable
 function [[over.match.viable]], or if `T` is an aggregate type
 [[dcl.init.aggr]] having a first element `x` and there is an implicit
 conversion sequence from E to the type of `x`. If `T` is a reference
 type, the effect is the same as performing the declaration and
 initialization
 for some invented temporary variable `t` [[dcl.init]] and then using the
 temporary variable as the result of the conversion. Otherwise, the
 result object is direct-initialized from E.
+[*Note 3*: The conversion is ill-formed when attempting to convert an
 expression of class type to an inaccessible or ambiguous base
 class. — *end note*]
+[*Note 4*: If `T` is “array of unknown bound of `U`”, this
 direct-initialization defines the type of the expression as
 `U[1]`. — *end note*]
+Otherwise, the lvalue-to-rvalue [[conv.lval]], array-to-pointer
+[[conv.array]], and function-to-pointer [[conv.func]] conversions are
+applied to the operand, and the conversions that can be performed using
+`static_cast` are listed below. No other conversion can be performed
+using `static_cast`.
 A value of a scoped enumeration type [[dcl.enum]] can be explicitly
 converted to an integral type; the result is the same as that of
 converting to the enumeration’s underlying type and then to the
 destination type. A value of a scoped enumeration type can also be
 If no valid standard conversion from “pointer to member of `B` of type
 `T`” to “pointer to member of `D` of type `T`” exists [[conv.mem]], the
 program is ill-formed. The null member pointer value [[conv.mem]] is
 converted to the null member pointer value of the destination type. If
+class `B` contains the original member, or is a base class of the class
+containing the original member, the resulting pointer to member points
+to the original member. Otherwise, the behavior is undefined.
 [*Note 6*: Although class `B` need not contain the original member, the
 dynamic type of the object with which indirection through the pointer to
 member is performed must contain the original member; see
 [[expr.mptr.oper]]. — *end note*]
 A prvalue of type “pointer to *cv1* `void`” can be converted to a
 prvalue of type “pointer to *cv2* `T`”, where `T` is an object type and
 *cv2* is the same cv-qualification as, or greater cv-qualification than,
 *cv1*. If the original pointer value represents the address `A` of a
 byte in memory and `A` does not satisfy the alignment requirement of
+`T`, then the resulting pointer value [[basic.compound]] is unspecified.
+Otherwise, if the original pointer value points to an object *a*, and
+there is an object *b* of type similar to `T` that is
+pointer-interconvertible [[basic.compound]] with *a*, the result is a
+pointer to *b*. Otherwise, the pointer value is unchanged by the
+conversion.
+[*Example 2*:
 ``` cpp
 T* p1 = new T;
 const T* p2 = static_cast<const T*>(static_cast<void*>(p1));
 bool b = p1 == p2;  // b will have the value true.
 any type to the type `std::nullptr_t`. — *end note*]
 A value of integral type or enumeration type can be explicitly converted
 to a pointer. A pointer converted to an integer of sufficient size (if
 any such exists on the implementation) and back to the same pointer type
+will have its original value [[basic.compound]]; mappings between
+pointers and integers are otherwise *implementation-defined*.
 A function pointer can be explicitly converted to a function pointer of
 a different type.
 [*Note 4*: The effect of calling a function through a pointer to a
 Except that converting a prvalue of type “pointer to `T1`” to the type
 “pointer to `T2`” (where `T1` and `T2` are function types) and back to
 its original type yields the original pointer value, the result of such
 a pointer conversion is unspecified.
 An object pointer can be explicitly converted to an object pointer of a
+different type.[^15]
 When a prvalue `v` of object pointer type is converted to the object
 pointer type “pointer to cv `T`”, the result is
 `static_cast<cv T*>(static_cast<cv~void*>(v))`.
+[*Note 5*: Converting a pointer of type “pointer to `T1`” that points
 to an object of type `T1` to the type “pointer to `T2`” (where `T2` is
 an object type and the alignment requirements of `T2` are no stricter
 than those of `T1`) and back to its original type yields the original
 pointer value. — *end note*]
 yield the original pointer value.
 The null pointer value [[basic.compound]] is converted to the null
 pointer value of the destination type.
+[*Note 6*: A null pointer constant of type `std::nullptr_t` cannot be
 converted to a pointer type, and a null pointer constant of integral
 type is not necessarily converted to a null pointer
 value. — *end note*]
 A prvalue of type “pointer to member of `X` of type `T1`” can be
 explicitly converted to a prvalue of a different type “pointer to member
 of `Y` of type `T2`” if `T1` and `T2` are both function types or both
+object types.[^16]
 The null member pointer value [[conv.mem]] is converted to the null
 member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
   `T1`” to the type “pointer to data member of `Y` of type `T2`” (where
   the alignment requirements of `T2` are no stricter than those of `T1`)
   and back to its original type yields the original pointer-to-member
   value.
+If `v` is a glvalue of type `T1`, designating an object or function *x*,
+it can be cast to the type “reference to `T2`” if an expression of type
+“pointer to `T1`” can be explicitly converted to the type “pointer to
+`T2`” using a `reinterpret_cast`. The result is that of
+`*reinterpret_cast<T2 *>(p)` where `p` is a pointer to *x* of type
+“pointer to `T1`”.
+[*Note 7*:
+No temporary is materialized [[conv.rval]] or created, no copy is made,
+and no constructors [[class.ctor]] or conversion functions
+[[class.conv]] are called.[^17]
+— *end note*]
 #### Const cast <a id="expr.const.cast">[[expr.const.cast]]</a>
 The result of the expression `const_cast<T>(v)` is of type `T`. If `T`
 is an lvalue reference to object type, the result is an lvalue; if `T`
 is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the lvalue-to-rvalue
 [[conv.lval]], array-to-pointer [[conv.array]], and function-to-pointer
 [[conv.func]] standard conversions are performed on the expression `v`.
+The temporary materialization conversion [[conv.rval]] is not performed
+on `v`, other than as specified below. Conversions that can be performed
+explicitly using `const_cast` are listed below. No other conversion
+shall be performed explicitly using `const_cast`.
 [*Note 1*: Subject to the restrictions in this subclause, an expression
 can be cast to its own type using a `const_cast`
 operator. — *end note*]
+For two similar object pointer or pointer to data member types `T1` and
+`T2` [[conv.qual]], a prvalue of type `T1` can be explicitly converted
+to the type `T2` using a `const_cast` if, considering the
+qualification-decompositions of both types, each P¹ᵢ is the same as P²ᵢ
+for all i. If `v` is a null pointer or null member pointer, the result
+is a null pointer or null member pointer, respectively. Otherwise, the
+result points to or past the end of the same object, or points to the
+same member, respectively, as `v`.
 For two object types `T1` and `T2`, if a pointer to `T1` can be
 explicitly converted to the type “pointer to `T2`” using a `const_cast`,
 then the following conversions can also be made:
 - an lvalue of type `T1` can be explicitly converted to an lvalue of
   type `T2` using the cast `const_cast<T2&>`;
 - a glvalue of type `T1` can be explicitly converted to an xvalue of
   type `T2` using the cast `const_cast<T2&&>`; and
+- if `T1` is a class or array type, a prvalue of type `T1` can be
+ explicitly converted to an xvalue of type `T2` using the cast
+  `const_cast<T2&&>`. The temporary materialization conversion is
+  performed on `v`.
+The result refers to the same object as the (possibly converted)
+operand.
+[*Example 1*:
+``` cpp
+typedef int *A[3];                  // array of 3 pointer to int
+typedef const int *const CA[3];     // array of 3 const pointer to const int
+auto &&r2 = const_cast<A&&>(CA{});  // OK, temporary materialization conversion is performed
+```
+— *end example*]
 [*Note 2*:
 Depending on the type of the object, a write operation through the
 pointer, lvalue or pointer to data member resulting from a `const_cast`
+that casts away a const-qualifier[^18]
 can produce undefined behavior [[dcl.type.cv]].
 — *end note*]

Diff to HTML by rtfpessoa