[expr] - C++11 → C++14

Files changed (1) hide show

tmp/tmp1zv6gor9/{from.md → to.md} +946 -597

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

@@ -38,10 +38,14 @@ If an expression initially has the type “reference to `T`” (
 [[dcl.ref]],  [[dcl.init.ref]]), the type is adjusted to `T` prior to
 any further analysis. The expression designates the object or function
 denoted by the reference, and the expression is an lvalue or an xvalue,
 depending on the expression.
 An expression is an xvalue if it is:
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type,
 - a cast to an rvalue reference to object type,
@@ -69,14 +73,15 @@ A&& ar = static_cast<A&&>(a);
 The expressions `f()`, `f().m`, `static_cast<A&&>(a)`, and `a + a` are
 xvalues. The expression `ar` is an lvalue.
 In some contexts, *unevaluated operands* appear ([[expr.typeid]],
 [[expr.sizeof]], [[expr.unary.noexcept]], [[dcl.type.simple]]). An
-unevaluated operand is not evaluated. In an unevaluated operand, a
-non-static class member may be named ([[expr.prim]]) and naming of
-objects or functions does not, by itself, require that a definition be
-provided ([[basic.def.odr]]).
 Whenever a glvalue expression appears as an operand of an operator that
 expects a prvalue for that operand, the lvalue-to-rvalue (
 [[conv.lval]]), array-to-pointer ([[conv.array]]), or
 function-to-pointer ([[conv.func]]) standard conversions are applied to
@@ -125,27 +130,76 @@ defined as follows:
 In some contexts, an expression only appears for its side effects. Such
 an expression is called a *discarded-value expression*. The expression
 is evaluated and its value is discarded. The array-to-pointer (
 [[conv.array]]) and function-to-pointer ([[conv.func]]) standard
 conversions are not applied. The lvalue-to-rvalue conversion (
-[[conv.lval]]) is applied only if the expression is an lvalue of
-volatile-qualified type and it has one of the following forms:
 - *id-expression* ([[expr.prim.general]]),
 - subscripting ([[expr.sub]]),
 - class member access ([[expr.ref]]),
 - indirection ([[expr.unary.op]]),
 - pointer-to-member operation ([[expr.mptr.oper]]),
 - conditional expression ([[expr.cond]]) where both the second and the
-  third operands are one of the above, or
 - comma expression ([[expr.comma]]) where the right operand is one of
- the above.
 The values of the floating operands and the results of floating
 expressions may be represented in greater precision and range than that
 required by the type; the types are not changed thereby.[^3]
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
 ### General <a id="expr.prim.general">[[expr.prim.general]]</a>
 ``` bnf
@@ -251,42 +305,40 @@ The result is an lvalue if the entity is a function, variable, or data
 member and a prvalue otherwise.
 ``` bnf
 qualified-id:
     nested-name-specifier 'template'ₒₚₜ unqualified-id
-    '::' identifier
-    '::' operator-function-id
-    '::' literal-operator-id
-    '::' template-id
 ```
 ``` bnf
 nested-name-specifier:
-    '::'ₒₚₜ type-name '::'
- '::'ₒₚₜ namespace-name '::'
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier 'template'ₒₚₜ simple-template-id '::'
 ```
 A *nested-name-specifier* that denotes a class, optionally followed by
 the keyword `template` ([[temp.names]]), and then followed by the name
 of a member of either that class ([[class.mem]]) or one of its base
 classes (Clause  [[class.derived]]), is a *qualified-id*;
 [[class.qual]] describes name lookup for class members that appear in
 *qualified-ids*. The result is the member. The type of the result is the
 type of the member. The result is an lvalue if the member is a static
 member function or a data member and a prvalue otherwise. a class member
 can be referred to using a *qualified-id* at any point in its potential
-scope ([[basic.scope.class]]). Where *class-name* `::` *class-name* is
-used, and the two *class-name*s refer to the same class, this notation
-names the constructor ([[class.ctor]]). Where *class-name* `::~`
-*class-name* is used, the two *class-name*s shall refer to the same
-class; this notation names the destructor ([[class.dtor]]). The form
-*\textasciitilde* *decltype-specifier* also denotes the destructor, but
-it shall not be used as the *unqualified-id* in a *qualified-id*. a
-*typedef-name* that names a class is a *class-name* ([[class.name]]).
 A `::`, or a *nested-name-specifier* that names a namespace (
 [[basic.namespace]]), in either case followed by the name of a member of
 that namespace (or the name of a member of a namespace made visible by a
 *using-directive*) is a *qualified-id*;  [[namespace.qual]] describes
@@ -311,14 +363,10 @@ member function of a class can only be used:
 - as part of a class member access ([[expr.ref]]) in which the object
   expression refers to the member’s class[^4] or a class derived from
   that class, or
 - to form a pointer to member ([[expr.unary.op]]), or
-- in a *mem-initializer* for a constructor for that class or for a class
-  derived from that class ([[class.base.init]]), or
-- in a *brace-or-equal-initializer* for a non-static data member of that
-  class or of a class derived from that class ([[class.base.init]]), or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
   ``` cpp
   struct S {
     int m;
@@ -372,39 +420,54 @@ capture-list:
     capture-list ',' capture '...'ₒₚₜ
 ```
 ``` bnf
 capture:
     identifier
     '&' identifier
     'this'
 ```
 ``` bnf
 lambda-declarator:
     '(' parameter-declaration-clause ')' 'mutable'ₒₚₜ
       exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
 ```
 The evaluation of a *lambda-expression* results in a prvalue temporary (
 [[class.temporary]]). This temporary is called the *closure object*. A
 *lambda-expression* shall not appear in an unevaluated operand (Clause
-[[expr]]). A closure object behaves like a function object (
-[[function.objects]]).
 The type of the *lambda-expression* (which is also the type of the
 closure object) is a unique, unnamed non-union class type — called the
 *closure type* — whose properties are described below. This class type
-is not an aggregate ([[dcl.init.aggr]]). The closure type is declared
-in the smallest block scope, class scope, or namespace scope that
-contains the corresponding *lambda-expression*. This determines the set
-of namespaces and classes associated with the closure type (
-[[basic.lookup.argdep]]). The parameter types of a *lambda-declarator*
-do not affect these associated namespaces and classes. An implementation
-may define the closure type differently from what is described below
-provided this does not alter the observable behavior of the program
-other than by changing:
 - the size and/or alignment of the closure type,
 - whether the closure type is trivially copyable (Clause  [[class]]),
 - whether the closure type is a standard-layout class (Clause
   [[class]]), or
@@ -412,52 +475,145 @@ other than by changing:
 An implementation shall not add members of rvalue reference type to the
 closure type.
 If a *lambda-expression* does not include a *lambda-declarator*, it is
-as if the *lambda-declarator* were `()`. If a *lambda-expression* does
-not include a *trailing-return-type*, it is as if the
-*trailing-return-type* denotes the following type:
-- if the *compound-statement* is of the form
-  ``` bnf
-  '{' attribute-specifier-seqₒₚₜ 'return' expression ';' '}'
-  ```
-  the type of the returned expression after lvalue-to-rvalue
-  conversion ([[conv.lval]]), array-to-pointer conversion (
-  [[conv.array]]), and function-to-pointer conversion ([[conv.func]]);
-- otherwise, `void`.
 ``` cpp
 auto x1 = [](int i){ return i; };     // OK: return type is int
-auto x2 = []{ return { 1, 2 }; }; // error: the return type is void (a
-                                  // braced-init-list is not an expression)
 ```
-The closure type for a *lambda-expression* has a public `inline`
-function call operator ([[over.call]]) whose parameters and return type
-are described by the *lambda-expression*’s
 *parameter-declaration-clause* and *trailing-return-type* respectively.
-This function call operator is declared `const` (
 [[class.mfct.non-static]]) if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable`. It is
-neither virtual nor declared `volatile`. Default arguments (
-[[dcl.fct.default]]) shall not be specified in the
-*parameter-declaration-clause* of a *lambda-declarator*. Any
-*exception-specification* specified on a *lambda-expression* applies to
-the corresponding function call operator. An *attribute-specifier-seq*
-in a *lambda-declarator* appertains to the type of the corresponding
-function call operator. Names referenced in the *lambda-declarator* are
-looked up in the context in which the *lambda-expression* appears.
-The closure type for a *lambda-expression* with no *lambda-capture* has
-a public non-virtual non-explicit const conversion function to pointer
-to function having the same parameter and return types as the closure
-type’s function call operator. The value returned by this conversion
-function shall be the address of a function that, when invoked, has the
-same effect as invoking the closure type’s function call operator.
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* ([[dcl.fct.def]]) of the function call operator, but
 for purposes of name lookup ([[basic.lookup]]), determining the type
 and value of `this` ([[class.this]]) and transforming *id-expression*s
@@ -477,16 +633,21 @@ struct S1 {
     };
   }
 };
 ```
-If a *lambda-capture* includes a *capture-default* that is `&`, the
-identifiers in the *lambda-capture* shall not be preceded by `&`. If a
-*lambda-capture* includes a *capture-default* that is `=`, the
-*lambda-capture* shall not contain `this` and each identifier it
-contains shall be preceded by `&`. An identifier or `this` shall not
-appear more than once in a *lambda-capture*.
 ``` cpp
 struct S2 { void f(int i); };
 void S2::f(int i) {
   [&, i]{ };    // OK
@@ -495,40 +656,89 @@ void S2::f(int i) {
   [i, i]{ };    // error: i repeated
 }
 ```
 A *lambda-expression* whose smallest enclosing scope is a block scope (
-[[basic.scope.local]]) is a *local lambda expression*; any other
-*lambda-expression* shall not have a *capture-list* in its
-*lambda-introducer*. The *reaching scope* of a local lambda expression
-is the set of enclosing scopes up to and including the innermost
-enclosing function and its parameters. This reaching scope includes any
-intervening *lambda-expression*s.
-The *identifiers* in a *capture-list* are looked up using the usual
 rules for unqualified name lookup ([[basic.lookup.unqual]]); each such
-lookup shall find a variable with automatic storage duration declared in
-the reaching scope of the local lambda expression. An entity (i.e. a
-variable or `this`) is said to be *explicitly captured* if it appears in
-the *lambda-expression*’s *capture-list*.
-If a *lambda-expression* has an associated *capture-default* and its
-*compound-statement* odr-uses ([[basic.def.odr]]) `this` or a variable
-with automatic storage duration and the odr-used entity is not
-explicitly captured, then the odr-used entity is said to be *implicitly
-captured*; such entities shall be declared within the reaching scope of
-the lambda expression. The implicit capture of an entity by a nested
-*lambda-expression* can cause its implicit capture by the containing
-*lambda-expression* (see below). Implicit odr-uses of `this` can result
-in implicit capture.
 An entity is *captured* if it is captured explicitly or implicitly. An
 entity captured by a *lambda-expression* is odr-used (
 [[basic.def.odr]]) in the scope containing the *lambda-expression*. If
 `this` is captured by a local lambda expression, its nearest enclosing
 function shall be a non-static member function. If a *lambda-expression*
-odr-uses ([[basic.def.odr]]) `this` or a variable with automatic
 storage duration from its reaching scope, that entity shall be captured
 by the *lambda-expression*. If a *lambda-expression* captures an entity
 and that entity is not defined or captured in the immediately enclosing
 lambda expression or function, the program is ill-formed.
@@ -578,22 +788,25 @@ void f2() {
 }
 ```
 An entity is *captured by copy* if it is implicitly captured and the
 *capture-default* is `=` or if it is explicitly captured with a capture
-that does not include an `&`. For each entity captured by copy, an
-unnamed non-static data member is declared in the closure type. The
-declaration order of these members is unspecified. The type of such a
-data member is the type of the corresponding captured entity if the
-entity is not a reference to an object, or the referenced type
-otherwise. If the captured entity is a reference to a function, the
-corresponding data member is also a reference to a function.
 An entity is *captured by reference* if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional
 unnamed non-static data members are declared in the closure type for
-entities captured by reference.
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
@@ -618,30 +831,30 @@ auto m1 = [a, &b, &c]() mutable {
 a = 2; b = 2; c = 2;
 m1();
 std::cout << a << b << c;
 ```
-Every *id-expression* that is an odr-use ([[basic.def.odr]]) of an
-entity captured by copy is transformed into an access to the
-corresponding unnamed data member of the closure type. An
-*id-expression* that is not an odr-use refers to the original entity,
-never to a member of the closure type. Furthermore, such an
-*id-expression* does not cause the implicit capture of the entity. If
-`this` is captured, each odr-use of `this` is transformed into an access
-to the corresponding unnamed data member of the closure type, cast (
-[[expr.cast]]) to the type of `this`. The cast ensures that the
-transformed expression is a prvalue.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
     int arr[N];             // OK: not an odr-use, refers to automatic variable
     f(&N);                  // OK: causes N to be captured; &N points to the
                             // corresponding member of the closure type
-  }
 }
 ```
 Every occurrence of `decltype((x))` where `x` is a possibly
 parenthesized *id-expression* that names an entity of automatic storage
@@ -673,24 +886,27 @@ implicitly defined.
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor ([[class.dtor]]).
 When the *lambda-expression* is evaluated, the entities that are
 captured by copy are used to direct-initialize each corresponding
-non-static data member of the resulting closure object. (For array
-members, the array elements are direct-initialized in increasing
-subscript order.) These initializations are performed in the
-(unspecified) order in which the non-static data members are declared.
-This ensures that the destructions will occur in the reverse order of
-the constructions.
 If an entity is implicitly or explicitly captured by reference, invoking
 the function call operator of the corresponding *lambda-expression*
 after the lifetime of the entity has ended is likely to result in
 undefined behavior.
-A *capture* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]).
 ``` cpp
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
@@ -744,64 +960,67 @@ The `>` token following the in a `dynamic_cast`, `static_cast`,
 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 ### Subscripting <a id="expr.sub">[[expr.sub]]</a>
 A postfix expression followed by an expression in square brackets is a
-postfix expression. One of the expressions shall have the type “pointer
-to `T`” and the other shall have unscoped enumeration or integral type.
-The result is an lvalue of type “`T`.” The type “`T`” shall be a
 completely-defined object type.[^5] The expression `E1[E2]` is identical
 (by definition) to `*((E1)+(E2))` see  [[expr.unary]] and  [[expr.add]]
-for details of `*` and `+` and  [[dcl.array]] for details of arrays.
 A *braced-init-list* shall not be used with the built-in subscript
 operator.
 ### Function call <a id="expr.call">[[expr.call]]</a>
-There are two kinds of function call: ordinary function call and member
-function[^6] ([[class.mfct]]) call. A function call is a postfix
-expression followed by parentheses containing a possibly empty,
-comma-separated list of expressions which constitute the arguments to
-the function. For an ordinary function call, 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 it shall have pointer to function type.
-Calling a function through an expression whose function type has a
-language linkage that is different from the language linkage of the
-function type of the called function’s definition is undefined (
-[[dcl.link]]). For a member function call, the postfix expression shall
-be an implicit ([[class.mfct.non-static]],  [[class.static]]) or
-explicit class member access ([[expr.ref]]) whose *id-expression* is a
-function member name, or a pointer-to-member expression (
-[[expr.mptr.oper]]) selecting a function member; the call is as a member
-of the class object referred to by the object expression. In the case of
-an implicit class member access, the implied object is the one pointed
-to by `this`. a member function call of the form `f()` is interpreted as
-`(*this).f()` (see  [[class.mfct.non-static]]). If a function or member
-function name is used, the name can be overloaded (Clause  [[over]]), in
-which case the appropriate function shall be selected according to the
-rules in  [[over.match]]. 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. 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.
 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.
 If the *postfix-expression* designates a destructor ([[class.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 `virtual` keyword), even if the type
-of the function actually called is different. This type shall be an
-object type, a reference type or the type `void`.
 When a function is called, each parameter ([[dcl.fct]]) shall be
 initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
 corresponding argument. Such initializations are indeterminately
 sequenced with respect to each other ([[intro.execution]]) If the
@@ -874,16 +1093,16 @@ 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*.
-The evaluations of the postfix expression and of the argument
-expressions are all unsequenced relative to one another. All side
-effects of argument expression evaluations are sequenced before the
-function is entered (see  [[intro.execution]]).
-Recursive calls are permitted, except to the function named `main` (
 [[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.
@@ -923,14 +1142,15 @@ temporary variable `t`, with the result being the value of `t` as a
 prvalue.
 The expression `T()`, where `T` is a *simple-type-specifier* or
 *typename-specifier* for a non-array complete object type or the
 (possibly cv-qualified) `void` type, creates a prvalue of the specified
-type,which is value-initialized ([[dcl.init]]; no initialization is
-done for the `void()` case). if `T` is a non-class type that is
-cv-qualified, the *cv-qualifier*s are ignored when determining the type
-of the resulting prvalue ([[basic.lval]]).
 Similarly, a *simple-type-specifier* or *typename-specifier* followed by
 a *braced-init-list* creates a temporary object of the specified type
 direct-list-initialized ([[dcl.init.list]]) with the specified
 *braced-init-list*, and its value is that temporary object as a prvalue.
@@ -960,19 +1180,19 @@ shall designate the same scalar 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` ([[temp.names]]), and then followed
 by an *id-expression*, is a postfix expression. The postfix expression
-before the dot or arrow is evaluated;[^7] the result of that evaluation,
 together with the *id-expression*, determines the result of the entire
 postfix expression.
 For the first option (dot) the first expression shall have complete
 class type. For the second option (arrow) the first expression shall
 have pointer to complete class 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).[^8] In either
 case, the *id-expression* shall name a member of the class or of one of
 its base classes. because the name of a class is inserted in its class
 scope (Clause  [[class]]), the name of a class is also considered a
 nested member of that class. [[basic.lookup.classref]] describes how
 names are looked up after the `.` and `->` operators.
@@ -992,19 +1212,19 @@ rules applies.
   `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 named member of the object designated by the first
-  expression. If `E1` is an lvalue, then `E1.E2` is an lvalue; if `E1`
- is an xvalue, then `E1.E2` is an xvalue; otherwise, it is a prvalue.
- 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 a (possibly overloaded) member function, function overload
   resolution ([[over.match]]) is used to determine whether `E1.E2`
   refers to a static or a non-static member function.
   - If it refers to a static member function and the type of `E2` is
     “function of parameter-type-list returning `T`”, then `E1.E2` is an
@@ -1077,11 +1297,11 @@ result is the null pointer value of type `T`.
 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`. 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`. [^9] The result is an lvalue if `T` is an
 lvalue reference, or an xvalue if `T` is an rvalue reference. In both
 the pointer and reference cases, the program is ill-formed if *cv2* has
 greater cv-qualification than *cv1* or if `B` is an inaccessible or
 ambiguous base class of `D`.
@@ -1091,11 +1311,11 @@ struct D : B { };
 void foo(D* dp) {
   B*  bp = dynamic_cast<B*>(dp);    // equivalent to B* bp = dp;
 }
 ```
-Otherwise, `v` shall be a pointer to or an lvalue of a polymorphic
 type ([[class.virtual]]).
 If `T` is “pointer to *cv* `void`,” then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a run-time check is
 applied to see if the object pointed or referred to by `v` can be
@@ -1115,12 +1335,13 @@ check logically executes as follows:
   result points (refers) to the `C` subobject of the most derived
   object.
 - Otherwise, the run-time check *fails*.
 The value of a failed cast to pointer type is the null pointer value of
-the required result type. A failed cast to reference type throws
-`std::bad_cast` ([[bad.cast]]).
 ``` cpp
 class A { virtual void f(); };
 class B { virtual void g(); };
 class D : public virtual A, private B { };
@@ -1154,22 +1375,23 @@ object under construction or destruction.
 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]].[^10] 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.
 When `typeid` is applied to a glvalue expression 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 expression is obtained by applying the
-unary `*` operator to a pointer[^11] and the pointer is a null pointer
-value ([[conv.ptr]]), the `typeid` expression throws the
 `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 (
@@ -1185,12 +1407,13 @@ 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. If the type of
 the *type-id* is a class type or a reference to a class type, the class
 shall be completely-defined.
-The top-level cv-qualifiers of the glvalue expression or the *type-id*
-that is the operand of `typeid` are always ignored.
 ``` cpp
 class D { /* ... */ };
 D d1;
 const D d2;
@@ -1225,30 +1448,34 @@ and `B` is neither a virtual base class of `D` nor a base class of a
 virtual base class of `D`. The result has type “*cv2* `D`.” An xvalue of
 type “*cv1* `B`” may be cast to type “rvalue reference to *cv2* `D`”
 with the same constraints as for an lvalue of type “*cv1* `B`.” If the
 object of type “*cv1* `B`” is actually a subobject of an object of type
 `D`, the result refers to the enclosing object of type `D`. Otherwise,
-the result of the cast is undefined.
 ``` cpp
 struct B { };
 struct D : public B { };
 D d;
 B &br = d;
 static_cast<D&>(br);            // produces lvalue to the original d object
 ```
-A glvalue of type “*cv1* `T1`” can be cast to type “rvalue reference to
-*cv2* `T2`” if “*cv2* `T2`” is reference-compatible with “*cv1* `T1`” (
-[[dcl.init.ref]]). The result refers to the object or the specified base
-class subobject thereof. If `T2` is an inaccessible (Clause
 [[class.access]]) or ambiguous ([[class.member.lookup]]) base class of
 `T1`, a program that necessitates such a cast is ill-formed.
-Otherwise, an expression `e` can be explicitly converted to a type `T`
-using a `static_cast` of the form `static_cast<T>(e)` if the declaration
 `T t(e);` is well-formed, for some invented temporary variable `t` (
 [[dcl.init]]). The effect of such an explicit conversion is the same as
 performing the declaration and initialization and then using the
 temporary variable as the result of the conversion. The expression `e`
 is used as a glvalue if and only if the initialization uses it as a
@@ -1288,24 +1515,27 @@ 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 value is unchanged if the original
-value can be represented by the specified type. Otherwise, the resulting
-value is unspecified. A value of a scoped enumeration type can also be
-explicitly converted to a floating-point type; the result is the same as
-that of converting from the original value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to
 an enumeration type. The value is unchanged if the original value is
 within the range of the enumeration values ([[dcl.enum]]). Otherwise,
 the resulting value is unspecified (and might not be in that range). A
-value of floating-point type can also be converted to an enumeration
-type. The resulting value is the same as converting the original value
-to the underlying type of the enumeration ([[conv.fpint]]), and
-subsequently to the enumeration type.
 A prvalue of type “pointer to *cv1* `B`,” where `B` is a class type, can
 be converted to a prvalue of type “pointer to *cv2* `D`,” where `D` is a
 class derived (Clause  [[class.derived]]) from `B`, if a valid standard
 conversion from “pointer to `D`” to “pointer to `B`” exists (
@@ -1314,34 +1544,38 @@ cv-qualification than, *cv1*, and `B` is neither a virtual base class of
 `D` nor a base class of a virtual base class of `D`. The null pointer
 value ([[conv.ptr]]) is converted to the null pointer value of the
 destination type. If the prvalue of type “pointer to *cv1* `B`” points
 to a `B` that is actually a subobject of an object of type `D`, the
 resulting pointer points to the enclosing object of type `D`. Otherwise,
-the result of the cast is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B`” of type *cv2*
 `T`, where `B` is a base class (Clause  [[class.derived]]) of `D`, if a
 valid standard conversion from “pointer to member of `B` of type `T`” to
 “pointer to member of `D` of type `T`” exists ([[conv.mem]]), and *cv2*
 is the same cv-qualification as, or greater cv-qualification than,
-*cv1*.[^12] 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 result of the cast is undefined.
-although class `B` need not contain the original member, the dynamic
-type of the object on which the pointer to member is dereferenced must
-contain the original member; see  [[expr.mptr.oper]].
 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*. The null pointer value is converted to the null pointer value of
-the destination type. A value of type pointer to object converted to
-“pointer to *cv* `void`” and back, possibly with different
-cv-qualification, shall have its original value.
 ``` 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.
@@ -1394,20 +1628,17 @@ prvalue of type “pointer to `T1`” to the type “pointer to `T2`” (where
 the original pointer value, the result of such a pointer conversion is
 unspecified. see also  [[conv.ptr]] for more details of pointer
 conversions.
 An object pointer can be explicitly converted to an object pointer of a
-different type.[^13] When a prvalue `v` of type “pointer to `T1`” is
-converted to the type “pointer to cv `T2`”, the result is
-`static_cast<cv T2*>(static_cast<cv void*>(v))` if both `T1` and `T2`
-are standard-layout types ([[basic.types]]) and the alignment
-requirements of `T2` are no stricter than those of `T1`, or if either
-type is `void`. Converting a prvalue of type “pointer to `T1`” to the
-type “pointer to `T2`” (where `T1` and `T2` are object types and where
-the alignment requirements of `T2` are no stricter than those of `T1`)
-and back to its original type yields the original pointer value. The
-result of any other such pointer conversion is unspecified.
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
@@ -1421,11 +1652,11 @@ pointer constant of integral type is not necessarily converted to a null
 pointer value.
 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.[^14] 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:
 - converting a prvalue of type “pointer to member function” to a
   different pointer to member function type and back to its original
@@ -1434,22 +1665,20 @@ 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.
-An lvalue expression of type `T1` 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`. That
-is, a reference cast `reinterpret_cast<T&>(x)` has the same effect as
-the conversion `*reinterpret_cast<T*>(&x)` with the built-in `&` and `*`
-operators (and similarly for `reinterpret_cast<T&&>(x)`). The result
-refers to the same object as the source lvalue, but with a different
-type. The result is an lvalue for an lvalue reference type or an rvalue
-reference to function type and an xvalue for an rvalue reference to
-object type. No temporary is created, no copy is made, and
-constructors ([[class.ctor]]) or conversion functions ([[class.conv]])
-are not called.[^15]
 ### 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`
@@ -1501,11 +1730,11 @@ value of the destination type. The null member pointer value (
 [[conv.mem]]) is converted to the null member pointer value of the
 destination type.
 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[^16] may produce undefined behavior (
 [[dcl.type.cv]]).
 The following rules define the process known as *casting away
 constness*. In these rules `Tn ` and `Xn ` represent types. For two
 pointer types:
@@ -1568,15 +1797,15 @@ unary-operator: one of
 The unary `*` operator performs *indirection*: the expression to which
 it is applied shall be a pointer to an object type, or a pointer to a
 function type and the result is an lvalue referring to the object or
 function to which the expression points. If the type of the expression
-is “pointer to `T`,” the type of the result is “`T`.” a pointer to an
-incomplete type (other than *cv* `void`) can be dereferenced. The lvalue
-thus obtained can be used in limited ways (to initialize a reference,
-for example); this lvalue must not be converted to a prvalue, see
-[[conv.lval]].
 The result of each of the following unary operators is a prvalue.
 The result of the unary `&` operator is a pointer to its operand. The
 operand shall be an lvalue or a *qualified-id*. If the operand is a
@@ -1608,14 +1837,14 @@ from a *qualified-id* for a non-static member function to the type
 “pointer to member function” as there is from an lvalue of function type
 to the type “pointer to function” ([[conv.func]]). Nor is
 `&unqualified-id` a pointer to member, even within the scope of the
 *unqualified-id*’s class.
-The address of an object of incomplete type can be taken, but if the
-complete type of that object is a class type that declares `operator&()`
-as a member function, then the behavior is undefined (and no diagnostic
-is required). The operand of `&` shall not be a bit-field.
 The address of an overloaded function (Clause  [[over]]) can be taken
 only in a context that uniquely determines which version of the
 overloaded function is referred to (see  [[over.over]]). since the
 context might determine whether the operand is a static or non-static
@@ -1670,27 +1899,27 @@ The `sizeof` operator yields the number of bytes in the object
 representation of its operand. The operand is either an expression,
 which is an unevaluated operand (Clause  [[expr]]), or a parenthesized
 *type-id*. The `sizeof` operator shall not be applied to an expression
 that has function or incomplete type, to an enumeration type whose
 underlying type is not fixed before all its enumerators have been
-declared, to the parenthesized name of such types, or to an lvalue that
 designates a bit-field. `sizeof(char)`, `sizeof(signed char)` and
 `sizeof(unsigned char)` are `1`. The result of `sizeof` applied to any
 other fundamental type ([[basic.fundamental]]) is
 *implementation-defined*. in particular, `sizeof(bool)`,
 `sizeof(char16_t)`, `sizeof(char32_t)`, and `sizeof(wchar_t)` are
-implementation-defined.[^17] See  [[intro.memory]] for the definition of
 *byte* and  [[basic.types]] for the definition of *object
 representation*.
 When applied to a reference or a reference type, the result is the size
 of the referenced type. When applied to a class, the result is the
 number of bytes in an object of that class including any padding
 required for placing objects of that type in an array. The size of a
 most derived class shall be greater than zero ([[intro.object]]). The
 result of applying `sizeof` to a base class subobject is the size of the
-base class type.[^18] When applied to an array, the result is the total
 number of bytes in the array. This implies that the size of an array of
 *n* elements is *n* times the size of an element.
 The `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
@@ -1829,35 +2058,43 @@ denotes an array type), the *new-expression* yields a pointer to the
 initial element (if any) of the array. both `new int` and `new int[10]`
 have type `int*` and the type of `new int[i][10]` is `int (*)[10]` The
 *attribute-specifier-seq* in a *noptr-new-declarator* appertains to the
 associated array type.
-Every *constant-expression* in a *noptr-new-declarator* shall be an
-integral constant expression ([[expr.const]]) and evaluate to a
-strictly positive value. The *expression* in a *noptr-new-declarator*
-shall be of integral type, unscoped enumeration type, or a class type
-for which a single non-explicit conversion function to integral or
-unscoped enumeration type exists ([[class.conv]]). If the expression is
-of class type, the expression is converted by calling that conversion
-function, and the result of the conversion is used in place of the
-original expression. given the definition `int n = 42`,
-`new float[n][5]` is well-formed (because `n` is the *expression* of a
-*noptr-new-declarator*), but `new float[5][n]` is ill-formed (because
-`n` is not a constant expression).
-When the value of the *expression* in a *noptr-new-declarator* is zero,
-the allocation function is called to allocate an array with no elements.
-If the value of that *expression* is less than zero or such that the
-size of the allocated object would exceed the implementation-defined
-limit, or if the *new-initializer* is a *braced-init-list* for which the
-number of *initializer-clause*s exceeds the number of elements to
-initialize, no storage is obtained and the *new-expression* terminates
-by throwing an exception of a type that would match a handler (
-[[except.handle]]) of type `std::bad_array_new_length` (
-[[new.badlength]]).
-A *new-expression* obtains storage for the object by calling an
 *allocation function* ([[basic.stc.dynamic.allocation]]). If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function (
 [[basic.stc.dynamic.deallocation]]). If the allocated type is a
 non-array type, the allocation function’s name is `operator new` and the
@@ -1875,24 +2112,76 @@ allocation function’s name is looked up in the global scope. Otherwise,
 if the allocated type is a class type `T` or array thereof, the
 allocation function’s name is looked up in the scope of `T`. If this
 lookup fails to find the name, or if the allocated type is not a class
 type, the allocation function’s name is looked up in the global scope.
-A *new-expression* passes the amount of space requested to the
-allocation function as the first argument of type `std::size_t`. That
-argument shall be no less than the size of the object being created; it
-may be greater than the size of the object being created only if the
-object is an array. For arrays of `char` and `unsigned char`, the
-difference between the result of the *new-expression* and the address
-returned by the allocation function shall be an integral multiple of the
-strictest fundamental alignment requirement ([[basic.align]]) of any
-object type whose size is no greater than the size of the array being
-created. Because allocation functions are assumed to return pointers to
-storage that is appropriately aligned for objects of any type with
-fundamental alignment, this constraint on array allocation overhead
-permits the common idiom of allocating character arrays into which
-objects of other types will later be placed.
 The *new-placement* syntax is used to supply additional arguments to an
 allocation function. If used, overload resolution is performed on a
 function call created by assembling an argument list consisting of the
 amount of space requested (the first argument) and the expressions in
@@ -1937,12 +2226,12 @@ necessarily be the same as that of the block if the object is an array.
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is
-  default-initialized ([[dcl.init]]); if no initialization is
-  performed, the object has indeterminate value.
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 The invocation of the allocation function is indeterminately sequenced
 with respect to the evaluations of expressions in the *new-initializer*.
@@ -1952,23 +2241,24 @@ expressions in the *new-initializer* are evaluated if the allocation
 function returns the null pointer or exits using an exception.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
 function, the deallocation function ([[class.free]]), and the
-constructor ([[class.ctor]]). If the new expression creates an array of
-objects of class type, access and ambiguity control are done for the
-destructor ([[class.dtor]]).
 If any part of the object initialization described above[^19] terminates
-by throwing an exception and a suitable deallocation function can be
-found, the deallocation function is called to free the memory in which
-the object was being constructed, after which the exception continues to
-propagate in the context of the *new-expression*. If no unambiguous
-matching deallocation function can be found, propagating the exception
-does not cause the object’s memory to be freed. This is appropriate when
-the called allocation function does not allocate memory; otherwise, it
-is likely to result in a memory leak.
 If the *new-expression* begins with a unary `::` operator, the
 deallocation function’s name is looked up in the global scope.
 Otherwise, if the allocated type is a class type `T` or an array
 thereof, the deallocation function’s name is looked up in the scope of
@@ -1977,19 +2267,19 @@ not a class type or array thereof, the deallocation function’s name is
 looked up in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations ([[dcl.fct]]), all
-parameter types except the first are identical. Any non-placement
-deallocation function matches a non-placement allocation function. If
-the lookup finds a single matching deallocation function, that function
-will be called; otherwise, no deallocation function will be called. If
-the lookup finds the two-parameter form of a usual deallocation
-function ([[basic.stc.dynamic.deallocation]]) and that function,
-considered as a placement deallocation function, would have been
-selected as a match for the allocation function, the program is
-ill-formed.
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);
@@ -2026,13 +2316,14 @@ delete-expression:
 ```
 The first alternative is for non-array objects, and the second is for
 arrays. Whenever the `delete` keyword is immediately followed by empty
 square brackets, it shall be interpreted as the second alternative.[^20]
-The operand shall have a pointer to object type, or a class type having
-a single non-explicit conversion function ([[class.conv.fct]]) to a
-pointer to object type. The result has type `void`.[^21]
 If the operand has a class type, the operand is converted to a pointer
 type by calling the above-mentioned conversion function, and the
 converted operand is used in place of the original operand for the
 remainder of this section. In the first alternative (*delete object*),
@@ -2071,41 +2362,74 @@ any) for the object or the elements of the array being deleted. In the
 case of an array, the elements will be destroyed in order of decreasing
 address (that is, in reverse order of the completion of their
 constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
-pointer value, the *delete-expression* will call a *deallocation
-function* ([[basic.stc.dynamic.deallocation]]). Otherwise, it is
-unspecified whether the deallocation function will be called. The
-deallocation function is called regardless of whether the destructor for
-the object or some element of the array throws an exception.
 An implementation provides default definitions of the global
 deallocation functions `operator delete()` for non-arrays (
 [[new.delete.single]]) and `operator delete[]()` for arrays (
 [[new.delete.array]]). A C++ program can provide alternative definitions
 of these functions ([[replacement.functions]]), and/or class-specific
 versions ([[class.free]]).
 When the keyword `delete` in a *delete-expression* is preceded by the
-unary `::` operator, the global deallocation function is used to
-deallocate the storage.
 Access and ambiguity control are done for both the deallocation function
 and the destructor ([[class.dtor]],  [[class.free]]).
 ### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
-type or an array thereof or a reference to a complete object type.
 The result is an integral constant of type `std::size_t`.
-When `alignof` is applied to a reference type, the result shall be the
 alignment of the referenced type. When `alignof` is applied to an array
-type, the result shall be the alignment of the element type.
 ### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 The `noexcept` operator determines whether the evaluation of its
 operand, which is an unevaluated operand (Clause  [[expr]]), can throw
@@ -2115,24 +2439,24 @@ an exception ([[except.throw]]).
 noexcept-expression:
   'noexcept' '(' expression ')'
 ```
 The result of the `noexcept` operator is a constant of type `bool` and
-is an rvalue.
 The result of the `noexcept` operator is `false` if in a
 potentially-evaluated context the *expression* would contain
-- a potentially evaluated call[^23] to a function, member function,
   function pointer, or member function pointer that does not have a
   non-throwing *exception-specification* ([[except.spec]]), unless the
   call is a constant expression ([[expr.const]]),
-- a potentially evaluated *throw-expression* ([[except.throw]]),
-- a potentially evaluated `dynamic_cast` expression
   `dynamic_cast<T>(v)`, where `T` is a reference type, that requires a
   run-time check ([[expr.dynamic.cast]]), or
-- a potentially evaluated `typeid` expression ([[expr.typeid]]) applied
   to a glvalue expression whose type is a polymorphic class type (
   [[class.virtual]]).
 Otherwise, the result is `true`.
@@ -2140,12 +2464,12 @@ Otherwise, the result is `true`.
 The result of the expression `(T)` *cast-expression* is of type `T`. The
 result is an lvalue if `T` is an lvalue reference type or an rvalue
 reference to function type and an xvalue if `T` is an rvalue reference
 to object type; otherwise the result is a prvalue. if `T` is a non-class
-type that is *cv-qualified*, the *cv-qualifiers* are ignored when
-determining the type of the resulting prvalue; see  [[basic.lval]].
 An explicit type conversion can be expressed using functional notation (
 [[expr.type.conv]]), a type conversion operator (`dynamic_cast`,
 `static_cast`, `reinterpret_cast`, `const_cast`), or the *cast*
 notation.
@@ -2220,21 +2544,20 @@ pm-expression:
     pm-expression '.*' cast-expression
     pm-expression '->*' cast-expression
 ```
 The binary operator `.*` binds its second operand, which shall be of
-type “pointer to member of `T`” (where `T` is a completely-defined class
-type) to its first operand, which shall be of class `T` or of a class of
-which `T` is an unambiguous and accessible base class. The result is an
-object or a function of the type specified by the second operand.
 The binary operator `->*` binds its second operand, which shall be of
-type “pointer to member of `T`” (where `T` is a completely-defined class
-type) to its first operand, which shall be of type “pointer to `T`” or
-“pointer to a class of which `T` is an unambiguous and accessible base
-class.” The expression `E1->*E2` is converted into the equivalent form
-`(*(E1)).*E2`.
 Abbreviating *pm-expression*`.*`*cast-expression* as `E1.*E2`, `E1` is
 called the *object expression*. If the dynamic type of `E1` does not
 contain the member to which `E2` refers, the behavior is undefined.
@@ -2270,12 +2593,12 @@ pointed to by `ptr_to_obj`. In a `.*` expression whose object expression
 is an rvalue, the program is ill-formed if the second operand is a
 pointer to member function with *ref-qualifier* `&`. In a `.*`
 expression whose object expression is an lvalue, the program is
 ill-formed if the second operand is a pointer to member function with
 *ref-qualifier* `&&`. The result of a `.*` expression whose second
-operand is a pointer to a data member is of the same value category (
-[[basic.lval]]) as its first operand. The result of a `.*` expression
 whose second operand is a pointer to a member function is a prvalue. If
 the second operand is the null pointer to member value ([[conv.mem]]),
 the behavior is undefined.
 ## Multiplicative operators <a id="expr.mul">[[expr.mul]]</a>
@@ -2299,13 +2622,13 @@ The binary `*` operator indicates multiplication.
 The binary `/` operator yields the quotient, and the binary `%` operator
 yields the remainder from the division of the first expression by the
 second. If the second operand of `/` or `%` is zero the behavior is
 undefined. For integral operands the `/` operator yields the algebraic
-quotient with any fractional part discarded;[^24] if the quotient `a/b`
 is representable in the type of the result, `(a/b)*b + a%b` is equal to
-`a`.
 ## Additive operators <a id="expr.add">[[expr.add]]</a>
 The additive operators `+` and `-` group left-to-right. The usual
 arithmetic conversions are performed for operands of arithmetic or
@@ -2375,11 +2698,17 @@ to the last element of the same array object, the expression
 `-((P)-((Q)+1))`, and has the value zero if the expression `P` points
 one past the last element of the array object, even though the
 expression `(Q)+1` does not point to an element of the array object.
 Unless both pointers point to elements of the same array object, or one
 past the last element of the array object, the behavior is
-undefined.[^25]
 If the value 0 is added to or subtracted from a pointer value, the
 result compares equal to the original pointer value. If two pointers
 point to the same object or both point one past the end of the same
 array or both are null, and the two pointers are subtracted, the result
@@ -2405,12 +2734,14 @@ left operand.
 The value of `E1 << E2` is `E1` left-shifted `E2` bit positions; vacated
 bits are zero-filled. If `E1` has an unsigned type, the value of the
 result is $\mathrm{E1}\times2^\mathrm{E2}$, reduced modulo one more than
 the maximum value representable in the result type. Otherwise, if `E1`
 has a signed type and non-negative value, and
-$\mathrm{E1}\times2^\mathrm{E2}$ is representable in the result type,
-then that is the resulting value; otherwise, the behavior is undefined.
 The value of `E1 >> E2` is `E1` right-shifted `E2` bit positions. If
 `E1` has an unsigned type or if `E1` has a signed type and a
 non-negative value, the value of the result is the integral part of the
 quotient of $\mathrm{E1}/2^\mathrm{E2}$. If `E1` has a signed type and a
@@ -2428,79 +2759,42 @@ relational-expression:
     relational-expression '>' shift-expression
     relational-expression '<=' shift-expression
     relational-expression '>=' shift-expression
 ```
-The operands shall have arithmetic, enumeration, or pointer type, or
-type `std::nullptr_t`. The operators `<` (less than), `>` (greater
-than), `<=` (less than or equal to), and `>=` (greater than or equal to)
-all yield `false` or `true`. The type of the result is `bool`.
 The usual arithmetic conversions are performed on operands of arithmetic
-or enumeration type. Pointer conversions ([[conv.ptr]]) and
-qualification conversions ([[conv.qual]]) are performed on pointer
-operands (or on a pointer operand and a null pointer constant, or on two
-null pointer constants, at least one of which is non-integral) to bring
-them to their *composite pointer type*. If one operand is a null pointer
-constant, the composite pointer type is `std::nullptr_t` if the other
-operand is also a null pointer constant or, if the other operand is a
-pointer, the type of the other operand. Otherwise, if one of the
-operands has type “pointer to *cv1* `void`,” then the other has type
-“pointer to *cv2* *T*” and the composite pointer type is “pointer to
-*cv12* `void`,” where *cv12* is the union of *cv1* and *cv2*. Otherwise,
-the composite pointer type is a pointer type similar ([[conv.qual]]) to
-the type of one of the operands, with a cv-qualification signature (
-[[conv.qual]]) that is the union of the cv-qualification signatures of
-the operand types. this implies that any pointer can be compared to a
-null pointer constant and that any object pointer can be compared to a
-pointer to (possibly cv-qualified) `void`.
-``` cpp
-void *p;
-const int *q;
-int **pi;
-const int *const *pci;
-void ct() {
-  p <= q;           // Both converted to const void* before comparison
-  pi <= pci;        // Both converted to const int *const * before comparison
-}
-```
-Pointers to objects or functions of the same type (after pointer
-conversions) can be compared, with a result defined as follows:
-- If two pointers `p` and `q` of the same type point to the same object
-  or function, or both point one past the end of the same array, or are
-  both null, then `p<=q` and `p>=q` both yield `true` and `p<q` and
- `p>q` both yield `false`.
-- If two pointers `p` and `q` of the same type point to different
-  objects that are not members of the same object or elements of the
-  same array or to different functions, or if only one of them is null,
-  the results of `p<q`, `p>q`, `p<=q`, and `p>=q` are unspecified.
-- If two pointers point to non-static data members of the same object,
-  or to subobjects or array elements of such members, recursively, the
-  pointer to the later declared member compares greater provided the two
-  members have the same access control (Clause  [[class.access]]) and
-  provided their class is not a union.
-- If two pointers point to non-static data members of the same object
-  with different access control (Clause  [[class.access]]) the result is
-  unspecified.
-- If two pointers point to non-static data members of the same union
-  object, they compare equal (after conversion to `void*`, if
-  necessary). If two pointers point to elements of the same array or one
-  beyond the end of the array, the pointer to the object with the higher
-  subscript compares higher.
-- Other pointer comparisons are unspecified.
-Pointers to `void` (after pointer conversions) can be compared, with a
-result defined as follows: If both pointers represent the same address
-or are both the null pointer value, the result is `true` if the operator
-is `<=` or `>=` and `false` otherwise; otherwise the result is
-unspecified.
-If two operands of type `std::nullptr_t` are compared, the result is
-`true` if the operator is `<=` or `>=`, and `false` otherwise.
 If both operands (after conversions) are of arithmetic or enumeration
 type, each of the operators shall yield `true` if the specified
 relationship is true and `false` if it is false.
@@ -2511,36 +2805,54 @@ equality-expression:
     relational-expression
     equality-expression '==' relational-expression
     equality-expression '!=' relational-expression
 ```
-The `==` (equal to) and the `!=` (not equal to) operators have the same
-semantic restrictions, conversions, and result type as the relational
-operators except for their lower precedence and truth-value result.
-`a<b == c<d` is `true` whenever `a<b` and `c<d` have the same
-truth-value. Pointers of the same type (after pointer conversions) can
-be compared for equality. Two pointers of the same type compare equal if
-and only if they are both null, both point to the same function, or both
-represent the same address ([[basic.compound]]).
-In addition, pointers to members can be compared, or a pointer to member
-and a null pointer constant. Pointer to member conversions (
-[[conv.mem]]) and qualification conversions ([[conv.qual]]) are
-performed to bring them to a common type. If one operand is a null
-pointer constant, the common type is the type of the other operand.
-Otherwise, the common type is a pointer to member type similar (
-[[conv.qual]]) to the type of one of the operands, with a
-cv-qualification signature ([[conv.qual]]) that is the union of the
-cv-qualification signatures of the operand types. this implies that any
-pointer to member can be compared to a null pointer constant. If both
-operands are null, they compare equal. Otherwise if only one is null,
-they compare unequal. Otherwise if either is a pointer to a virtual
-member function, the result is unspecified. Otherwise they compare equal
-if and only if they would refer to the same member of the same most
-derived object ([[intro.object]]) or the same subobject if they were
-dereferenced with a hypothetical object of the associated class type.
   ``` cpp
   struct B {
     int f();
   };
   struct L : B { };
@@ -2551,17 +2863,26 @@ int (B::*pb)() = &B::f;
   int (L::*pl)() = pb;
   int (R::*pr)() = pb;
   int (D::*pdl)() = pl;
   int (D::*pdr)() = pr;
   bool x = (pdl == pdr);          // false
   ```
-If two operands of type `std::nullptr_t` are compared, the result is
-`true` if the operator is `==`, and `false` otherwise.
-Each of the operators shall yield `true` if the specified relationship
-is true and `false` if it is false.
 ## Bitwise AND operator <a id="expr.bit.and">[[expr.bit.and]]</a>
 ``` bnf
 and-expression:
@@ -2604,11 +2925,11 @@ logical-and-expression:
     inclusive-or-expression
     logical-and-expression '&&' inclusive-or-expression
 ```
 The `&&` operator groups left-to-right. The operands are both
-contextually converted to type `bool` (Clause  [[conv]]). The result is
 `true` if both operands are `true` and `false` otherwise. Unlike `&`,
 `&&` guarantees left-to-right evaluation: the second operand is not
 evaluated if the first operand is `false`.
 The result is a `bool`. If the second expression is evaluated, every
@@ -2650,19 +2971,16 @@ of the second expression, otherwise that of the third expression. Only
 one of the second and third expressions is evaluated. Every value
 computation and side effect associated with the first expression is
 sequenced before every value computation and side effect associated with
 the second or third expression.
-If either the second or the third operand has type `void`, then the
-lvalue-to-rvalue ([[conv.lval]]), array-to-pointer ([[conv.array]]),
-and function-to-pointer ([[conv.func]]) standard conversions are
-performed on the second and third operands, and one of the following
-shall hold:
-- The second or the third operand (but not both) is a
-  *throw-expression* ([[except.throw]]); the result is of the type of
-  the other and is a prvalue.
 - Both the second and the third operands have type `void`; the result is
   of type `void` and is a prvalue. This includes the case where both
   operands are *throw-expression*s.
 Otherwise, if the second and third operand have different types and
@@ -2678,11 +2996,11 @@ expression `E2` of type `T2` is defined as follows:
   reference to `T2`”, subject to the constraint that in the conversion
   the reference must bind directly ([[dcl.init.ref]]) to an lvalue.
 - If `E2` is an xvalue: `E1` can be converted to match `E2` if `E1` can
   be implicitly converted to the type “rvalue reference to `T2`”,
   subject to the constraint that the reference must bind directly.
-- If `E2` is an rvalue or if neither of the conversions above can be
   done and at least one of the operands has (possibly cv-qualified)
   class type:
   - if `E1` and `E2` have class type, and the underlying class types are
     the same or one is a base class of the other: `E1` can be converted
     to match `E2` if the class of `T2` is the same type as, or a base
@@ -2698,18 +3016,18 @@ expression `E2` of type `T2` is defined as follows:
     match `E2` if `E1` can be implicitly converted to the type that
     expression `E2` would have if `E2` were converted to a prvalue (or
     the type it has, if `E2` is a prvalue).
 Using this process, it is determined whether the second operand can be
- converted to match the third operand, and whether the third operand
-  can be converted to match the second operand. If both can be
-  converted, or one can be converted but the conversion is ambiguous,
-  the program is ill-formed. If neither can be converted, the operands
-  are left unchanged and further checking is performed as described
-  below. If exactly one conversion is possible, that conversion is
-  applied to the chosen operand and the converted operand is used in
-  place of the original operand for the remainder of this section.
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
@@ -2734,23 +3052,22 @@ of the following shall hold:
   the second operand or the third operand depending on the value of the
   first operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions are performed to bring them to a common
   type, and the result is of that type.
-- The second and third operands have pointer type, or one has pointer
- type and the other is a null pointer constant, or both are null
-  pointer constants, at least one of which is non-integral; pointer
-  conversions ([[conv.ptr]]) and qualification conversions (
   [[conv.qual]]) are performed to bring them to their composite pointer
-  type ([[expr.rel]]). The result is of the composite pointer type.
-- The second and third operands have pointer to member type, or one has
-  pointer to member type and the other is a null pointer constant;
- pointer to member conversions ([[conv.mem]]) and qualification
- conversions ([[conv.qual]]) are performed to bring them to a common
- type, whose cv-qualification shall match the cv-qualification of
-  either the second or the third operand. The result is of the common
-  type.
 ## Assignment and compound assignment operators <a id="expr.ass">[[expr.ass]]</a>
 The assignment operator (`=`) and the compound assignment operators all
 group right-to-left. All require a modifiable lvalue as their left
@@ -2811,16 +3128,16 @@ may be aliased in general. See  [[basic.lval]].
 A *braced-init-list* may appear on the right-hand side of
 - an assignment to a scalar, in which case the initializer list shall
   have at most a single element. The meaning of `x={v}`, where `T` is
-  the scalar type of the expression `x`, is that of `x=T(v)` except that
- no narrowing conversion ([[dcl.init.list]]) is allowed. The meaning
- of `x={}` is `x=T()`.
-- an assignment defined by a user-defined assignment operator, in which
- case the initializer list is passed as the argument to the operator
- function.
 ``` cpp
 complex<double> z;
 z = { 1,2 };              // meaning z.operator=({1,2\)}
 z += { 1, 2 };            // meaning z.operator+=({1,2\)}
@@ -2839,16 +3156,18 @@ expression:
     expression ',' assignment-expression
 ```
 A pair of expressions separated by a comma is evaluated left-to-right;
 the left expression is a discarded-value expression (Clause
-[[expr]]).[^26] Every value computation and side effect associated with
 the left expression is sequenced before every value computation and side
 effect associated with the right expression. The type and value of the
 result are the type and value of the right operand; the result is of the
 same value category as its right operand, and is a bit-field if its
-right operand is a glvalue and a bit-field.
 In contexts where comma is given a special meaning, in lists of
 arguments to functions ([[expr.call]]) and lists of initializers (
 [[dcl.init]]) the comma operator as described in Clause  [[expr]] can
 appear only in parentheses.
@@ -2871,126 +3190,147 @@ during translation.
 ``` bnf
 constant-expression:
     conditional-expression
 ```
-A *conditional-expression* is a *core constant expression* unless it
-involves one of the following as a potentially evaluated subexpression (
-[[basic.def.odr]]), but subexpressions of logical AND (
-[[expr.log.and]]), logical OR ([[expr.log.or]]), and conditional (
-[[expr.cond]]) operations that are not evaluated are not considered An
-overloaded operator invokes a function.:
-- `this` ([[expr.prim]]) unless it appears as the *postfix-expression*
- in a class member access expression, including the result of the
-  implicit transformation in the body of a non-static member function (
-  [[class.mfct.non-static]]);
 - an invocation of a function other than a `constexpr` constructor for a
-  literal class or a `constexpr` function Overload resolution (
   [[over.match]]) is applied as usual ;
 - an invocation of an undefined `constexpr` function or an undefined
-  `constexpr` constructor outside the definition of a `constexpr`
-  function or a `constexpr` constructor;
-- an invocation of a `constexpr` function with arguments that, when
-  substituted by function invocation substitution ([[dcl.constexpr]]),
-  do not produce a constant expression;
-  ``` cpp
-  constexpr const int* addr(const int& ir) { return &ir; }  // OK
-  static const int x = 5;
-  constexpr const int* xp = addr(x);  // OK: (const int*)&(const int&)x is an
-                                      // address constant expression
-  constexpr const int* tp = addr(5);  // error, initializer for constexpr variable not a constant
-                                      // expression; (const int*)&(const int&)5 is not a constant
-                                      // expression because it takes the address of a temporary
-  ```
-- an invocation of a `constexpr` constructor with arguments that, when
-  substituted by function invocation substitution ([[dcl.constexpr]]),
-  do not produce all constant expressions for the constructor calls and
-  full-expressions in the *mem-initializer*s;
-  ``` 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 after substitution
-  constexpr int w = A(false).m;       // error: initializer for m is
-                                      // x, which is non-constant
-  ```
-- an invocation of a `constexpr` function or a `constexpr` constructor
-  that would exceed the implementation-defined recursion limits (see
   Annex  [[implimits]]);
-- a result that is not mathematically defined or not in the range of
- representable values for its type;
 - a *lambda-expression* ([[expr.prim.lambda]]);
 - an lvalue-to-rvalue conversion ([[conv.lval]]) unless it is applied
   to
-  - a glvalue of integral or enumeration type that refers to a
-    non-volatile const object with a preceding initialization,
-    initialized with a constant expression, or
-  - a glvalue of literal type that refers to a non-volatile object
-    defined with `constexpr`, or that refers to a sub-object of such an
- object, or
-  - a glvalue of literal type that refers to a non-volatile temporary
-    object whose lifetime has not ended, initialized with a constant
- expression;
-- 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 *id-expression* that refers to a variable or data member of
-  reference type unless the reference has a preceding initialization,
- initialized with a constant expression;
 - a dynamic cast ([[expr.dynamic.cast]]);
 - a `reinterpret_cast` ([[expr.reinterpret.cast]]);
 - a pseudo-destructor call ([[expr.pseudo]]);
-- increment or decrement operations ([[expr.post.incr]],
-  [[expr.pre.incr]]);
-- a typeid expression ([[expr.typeid]]) whose operand is of a
   polymorphic class type;
 - a *new-expression* ([[expr.new]]);
 - a *delete-expression* ([[expr.delete]]);
-- a subtraction ([[expr.add]]) where both operands are pointers;
 - a relational ([[expr.rel]]) or equality ([[expr.eq]]) operator where
-  the result is unspecified;
-- an assignment or a compound assignment ([[expr.ass]]); or
 - a *throw-expression* ([[except.throw]]).
-A *literal constant expression* is a prvalue core constant expression of
-literal type, but not pointer type. An *integral constant expression* is
-a literal constant expression of integral or unscoped enumeration type.
-Such expressions may be used as array bounds ([[dcl.array]],
-[[expr.new]]), as bit-field lengths ([[class.bit]]), as enumerator
-initializers if the underlying type is not fixed ([[dcl.enum]]), as
-null pointer constants ([[conv.ptr]]), and as alignments (
-[[dcl.align]]). A *converted constant expression* of type `T` is a
-literal constant expression, implicitly converted to type `T`, where the
-implicit conversion (if any) is permitted in a literal constant
-expression and the implicit conversion sequence contains only
-user-defined conversions, lvalue-to-rvalue conversions ([[conv.lval]]),
-integral promotions ([[conv.prom]]), and integral conversions (
-[[conv.integral]]) other than narrowing conversions (
-[[dcl.init.list]]). such expressions may be used as case expressions (
-[[stmt.switch]]), as enumerator initializers if the underlying type is
-fixed ([[dcl.enum]]), and as integral or enumeration non-type template
-arguments ([[temp.arg]]). A *reference constant expression* is an
-lvalue core constant expression that designates an object with static
-storage duration or a function. An *address constant expression* is a
-prvalue core constant expression of pointer type that evaluates to the
-address of an object with static storage duration, to the address of a
-function, or to a null pointer value, or a prvalue core constant
-expression of type `std::nullptr_t`. Collectively, literal constant
-expressions, reference constant expressions, and address constant
-expressions are called *constant expressions*.
-Although in some contexts constant expressions must be evaluated during
-program translation, others may be evaluated during program execution.
 Since this International Standard 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.[^27]
 ``` 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
@@ -2999,20 +3339,20 @@ bool f() {
 ```
 It is unspecified whether the value of `f()` will be `true` or `false`.
 If an expression of literal class type is used in a context where an
-integral constant expression is required, then that class type shall
-have a single non-explicit conversion function to an integral or
-unscoped enumeration type and that conversion function shall be
 `constexpr`.
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
-  constexpr operator int() { return val; }
-  constexpr operator long() { return 43; }
 private:
   int val;
 };
 template<int> struct X { };
 constexpr A a = 42;
@@ -3032,12 +3372,12 @@ int ary[a];         // error: ambiguous conversion
 [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.md#basic.lval
 [basic.namespace]: dcl.md#basic.namespace
 [basic.scope.class]: basic.md#basic.scope.class
-[basic.scope.local]: basic.md#basic.scope.local
 [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
@@ -3080,16 +3420,16 @@ int ary[a];         // error: ambiguous conversion
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
-[dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.dcl]: dcl.md#dcl.dcl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
@@ -3159,20 +3499,22 @@ int ary[a];         // error: ambiguous conversion
 [new.delete.single]: language.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [over.built]: over.md#over.built
 [over.call]: over.md#over.call
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.oper]: over.md#over.match.oper
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [support.types]: language.md#support.types
 [temp.arg]: temp.md#temp.arg
 [temp.names]: temp.md#temp.names
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [type.info]: language.md#type.info
@@ -3191,53 +3533,55 @@ int ary[a];         // error: ambiguous conversion
     `(*this)` ([[class.mfct.non-static]]).
 [^5]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
-[^6]: A static member function ([[class.static]]) is an ordinary
-    function.
-[^7]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
-[^8]: Note that `(*(E1))` is an lvalue.
-[^9]: The most derived object ([[intro.object]]) pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
-[^10]: The recommended name for such a class is `extended_type_info`.
-[^11]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
     `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
-[^12]: Function types (including those used in pointer to member
     function types) are never cv-qualified; see  [[dcl.fct]].
-[^13]: The types may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^14]: `T1` and `T2` may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
-[^15]: This is sometimes referred to as a *type pun*.
-[^16]: `const_cast`
     is not limited to conversions that cast away a const-qualifier.
-[^17]: `sizeof(bool)` is not required to be `1`.
-[^18]: The actual size of a base class subobject may be less than the
     result of applying `sizeof` to the subobject, due to virtual base
     classes and less strict padding requirements on base class
     subobjects.
 [^19]: This may include evaluating a *new-initializer* and/or calling a
     constructor.
 [^20]: A lambda expression with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the lambda
@@ -3248,16 +3592,21 @@ int ary[a];         // error: ambiguous conversion
 [^22]: For non-zero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
-[^23]: This includes implicit calls such as the call to an allocation
     function in a *new-expression*.
-[^24]: This is often called truncation towards zero.
-[^25]: Another way to approach pointer arithmetic is first to convert
     the pointer(s) to character pointer(s): In this scheme the integral
     value of the expression added to or subtracted from the converted
     pointer is first multiplied by the size of the object originally
     pointed to, and the resulting pointer is converted back to the
     original type. For pointer subtraction, the result of the difference
@@ -3267,13 +3616,13 @@ int ary[a];         // error: ambiguous conversion
     When viewed in this way, an implementation need only provide one
     extra byte (which might overlap another object in the program) just
     after the end of the object in order to satisfy the “one past the
     last element” requirements.
-[^26]: However, an invocation of an overloaded comma operator is an
     ordinary function call; hence, the evaluations of its argument
     expressions are unsequenced relative to one another (see
     [[intro.execution]]).
-[^27]: Nonetheless, implementations are encouraged to provide consistent
-    results, irrespective of whether the evaluation was actually
- performed during translation or during program execution.

 [[dcl.ref]],  [[dcl.init.ref]]), the type is adjusted to `T` prior to
 any further analysis. The expression designates the object or function
 denoted by the reference, and the expression is an lvalue or an xvalue,
 depending on the expression.
+If a prvalue initially has the type “cv `T`,” where `T` is a
+cv-unqualified non-class, non-array type, the type of the expression is
+adjusted to `T` prior to any further analysis.
 An expression is an xvalue if it is:
 - the result of calling a function, whether implicitly or explicitly,
   whose return type is an rvalue reference to object type,
 - a cast to an rvalue reference to object type,
 The expressions `f()`, `f().m`, `static_cast<A&&>(a)`, and `a + a` are
 xvalues. The expression `ar` is an lvalue.
 In some contexts, *unevaluated operands* appear ([[expr.typeid]],
 [[expr.sizeof]], [[expr.unary.noexcept]], [[dcl.type.simple]]). An
+unevaluated operand is not evaluated. An unevaluated operand is
+considered a full-expression. In an unevaluated operand, a non-static
+class member may be named ([[expr.prim]]) and naming of objects or
+functions does not, by itself, require that a definition be provided (
+[[basic.def.odr]]).
 Whenever a glvalue expression appears as an operand of an operator that
 expects a prvalue for that operand, the lvalue-to-rvalue (
 [[conv.lval]]), array-to-pointer ([[conv.array]]), or
 function-to-pointer ([[conv.func]]) standard conversions are applied to
 In some contexts, an expression only appears for its side effects. Such
 an expression is called a *discarded-value expression*. The expression
 is evaluated and its value is discarded. The array-to-pointer (
 [[conv.array]]) and function-to-pointer ([[conv.func]]) standard
 conversions are not applied. The lvalue-to-rvalue conversion (
+[[conv.lval]]) is applied if and only if the expression is a glvalue of
+volatile-qualified type and it is one of the following:
+- `(` *expression* `)`, where *expression* is one of these expressions,
 - *id-expression* ([[expr.prim.general]]),
 - subscripting ([[expr.sub]]),
 - class member access ([[expr.ref]]),
 - indirection ([[expr.unary.op]]),
 - pointer-to-member operation ([[expr.mptr.oper]]),
 - conditional expression ([[expr.cond]]) where both the second and the
+  third operands are one of these expressions, or
 - comma expression ([[expr.comma]]) where the right operand is one of
+ these expressions.
+Using an overloaded operator causes a function call; the above covers
+only operators with built-in meaning. If the lvalue is of class type, it
+must have a volatile copy constructor to initialize the temporary that
+is the result of the lvalue-to-rvalue conversion.
 The values of the floating operands and the results of floating
 expressions may be represented in greater precision and range than that
 required by the type; the types are not changed thereby.[^3]
+The *cv-combined type* of two types `T1` and `T2` is a type `T3` similar
+to `T1` whose cv-qualification signature ([[conv.qual]]) is:
+- for every j > 0, cv$_{3,j}$ is the union of cv$_{1,j}$ and cv$_{2,j}$;
+- if the resulting cv$_{3,j}$ is different from cv$_{1,j}$ or
+  cv$_{2,j}$, then `const` is added to every cv$_{3,k}$ for 0 < k < j.
+Given similar types `T1` and `T2`, this construction ensures that both
+can be converted to `T3`. The *composite pointer type* of two operands
+`p1` and `p2` having types `T1` and `T2`, respectively, where at least
+one is a pointer or pointer to member type or `std::nullptr_t`, is:
+- if both `p1` and `p2` are null pointer constants, `std::nullptr_t`;
+- if either `p1` or `p2` is a null pointer constant, `T2` or `T1`,
+  respectively;
+- if `T1` or `T2` is “pointer to *cv1* `void`” and the other type is
+  “pointer to *cv2* T”, “pointer to *cv12* `void`”, where *cv12* is the
+  union of *cv1* and *cv2*;
+- if `T1` is “pointer to *cv1* `C1`” and `T2` is “pointer to *cv2*
+  `C2`”, where `C1` is reference-related to `C2` or `C2` is
+  reference-related to `C1` ([[dcl.init.ref]]), the cv-combined type of
+  `T1` and `T2` or the cv-combined type of `T2` and `T1`, respectively;
+- if `T1` is “pointer to member of `C1` of type *cv1* `U1`” and `T2` is
+  “pointer to member of `C2` of type *cv2* `U2`” where `C1` is
+  reference-related to `C2` or `C2` is reference-related to `C1` (
+  [[dcl.init.ref]]), the cv-combined type of `T2` and `T1` or the
+  cv-combined type of `T1` and `T2`, respectively;
+- if `T1` and `T2` are similar multi-level mixed pointer and pointer to
+  member types ([[conv.qual]]), the cv-combined type of `T1` and `T2`;
+- otherwise, a program that necessitates the determination of a
+  composite pointer type is ill-formed.
+``` cpp
+typedef void *p;
+typedef const int *q;
+typedef int **pi;
+typedef const int **pci;
+```
+The composite pointer type of `p` and `q` is “pointer to `const void`”;
+the composite pointer type of `pi` and `pci` is “pointer to `const`
+pointer to `const int`”.
 ## Primary expressions <a id="expr.prim">[[expr.prim]]</a>
 ### General <a id="expr.prim.general">[[expr.prim.general]]</a>
 ``` bnf
 member and a prvalue otherwise.
 ``` bnf
 qualified-id:
     nested-name-specifier 'template'ₒₚₜ unqualified-id
 ```
 ``` bnf
 nested-name-specifier:
+    '::'
+ type-name '::'
+    namespace-name '::'
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier 'template'ₒₚₜ simple-template-id '::'
 ```
+The type denoted by a *decltype-specifier* in a *nested-name-specifier*
+shall be a class or enumeration type.
 A *nested-name-specifier* that denotes a class, optionally followed by
 the keyword `template` ([[temp.names]]), and then followed by the name
 of a member of either that class ([[class.mem]]) or one of its base
 classes (Clause  [[class.derived]]), is a *qualified-id*;
 [[class.qual]] describes name lookup for class members that appear in
 *qualified-ids*. The result is the member. The type of the result is the
 type of the member. The result is an lvalue if the member is a static
 member function or a data member and a prvalue otherwise. a class member
 can be referred to using a *qualified-id* at any point in its potential
+scope ([[basic.scope.class]]). Where *class-name* `::~` *class-name* is
+used, the two *class-name*s shall refer to the same class; this notation
+names the destructor ([[class.dtor]]). The form
+`~` *decltype-specifier* also denotes the destructor, but it shall not
+be used as the *unqualified-id* in a *qualified-id*. a *typedef-name*
+that names a class is a *class-name* ([[class.name]]).
 A `::`, or a *nested-name-specifier* that names a namespace (
 [[basic.namespace]]), in either case followed by the name of a member of
 that namespace (or the name of a member of a namespace made visible by a
 *using-directive*) is a *qualified-id*;  [[namespace.qual]] describes
 - as part of a class member access ([[expr.ref]]) in which the object
   expression refers to the member’s class[^4] or a class derived from
   that class, or
 - to form a pointer to member ([[expr.unary.op]]), or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
   ``` cpp
   struct S {
     int m;
     capture-list ',' capture '...'ₒₚₜ
 ```
 ``` bnf
 capture:
+    simple-capture
+    init-capture
+```
+``` bnf
+simple-capture:
     identifier
     '&' identifier
     'this'
 ```
+``` bnf
+init-capture:
+    identifier initializer
+    '&' identifier initializer
+```
 ``` bnf
 lambda-declarator:
     '(' parameter-declaration-clause ')' 'mutable'ₒₚₜ
       exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
 ```
 The evaluation of a *lambda-expression* results in a prvalue temporary (
 [[class.temporary]]). This temporary is called the *closure object*. A
 *lambda-expression* shall not appear in an unevaluated operand (Clause
+[[expr]]), in a *template-argument*, in an *alias-declaration*, in a
+typedef declaration, or in the declaration of a function or function
+template outside its function body and default arguments. The intention
+is to prevent lambdas from appearing in a signature. A closure object
+behaves like a function object ([[function.objects]]).
 The type of the *lambda-expression* (which is also the type of the
 closure object) is a unique, unnamed non-union class type — called the
 *closure type* — whose properties are described below. This class type
+is neither an aggregate ([[dcl.init.aggr]]) nor a literal type (
+[[basic.types]]). The closure type is declared in the smallest block
+scope, class scope, or namespace scope that contains the corresponding
+*lambda-expression*. This determines the set of namespaces and classes
+associated with the closure type ([[basic.lookup.argdep]]). The
+parameter types of a *lambda-declarator* do not affect these associated
+namespaces and classes. An implementation may define the closure type
+differently from what is described below provided this does not alter
+the observable behavior of the program other than by changing:
 - the size and/or alignment of the closure type,
 - whether the closure type is trivially copyable (Clause  [[class]]),
 - whether the closure type is a standard-layout class (Clause
   [[class]]), or
 An implementation shall not add members of rvalue reference type to the
 closure type.
 If a *lambda-expression* does not include a *lambda-declarator*, it is
+as if the *lambda-declarator* were `()`. The lambda return type is
+`auto`, which is replaced by the *trailing-return-type* if provided
+and/or deduced from `return` statements as described in
+[[dcl.spec.auto]].
 ``` cpp
 auto x1 = [](int i){ return i; };     // OK: return type is int
+auto x2 = []{ return { 1, 2 }; }; // error: deducing return type from braced-init-list
+int j;
+auto x3 = []()->auto&& { return j; }; // OK: return type is int&
 ```
+The closure type for a non-generic *lambda-expression* has a public
+inline function call operator ([[over.call]]) whose parameters and
+return type are described by the *lambda-expression*’s
 *parameter-declaration-clause* and *trailing-return-type* respectively.
+For a generic lambda, the closure type has a public inline function call
+operator member template ([[temp.mem]]) whose *template-parameter-list*
+consists of one invented type *template-parameter* for each occurrence
+of `auto` in the lambda’s *parameter-declaration-clause*, in order of
+appearance. The invented type *template-parameter* is a parameter pack
+if the corresponding *parameter-declaration* declares a function
+parameter pack ([[dcl.fct]]). The return type and function parameters
+of the function call operator template are derived from the
+*lambda-expression*'s *trailing-return-type* and
+*parameter-declaration-clause* by replacing each occurrence of `auto` in
+the *decl-specifier*s of the *parameter-declaration-clause* with the
+name of the corresponding invented *template-parameter*.
+``` cpp
+auto glambda = [](auto a, auto&& b) { return a < b; };
+  bool b = glambda(3, 3.14);                                  // OK
+  auto vglambda = [](auto printer) {
+     return [=](auto&& ... ts) {                              // OK: ts is a function parameter pack
+         printer(std::forward<decltype(ts)>(ts)...);
+         return [=]() {
+           printer(ts ...);
+         };
+     };
+  };
+  auto p = vglambda( [](auto v1, auto v2, auto v3)
+                         { std::cout << v1 << v2 << v3; } );
+  auto q = p(1, 'a', 3.14);                                   // OK: outputs 1a3.14
+  q();                                                        // OK: outputs 1a3.14
+```
+This function call operator or operator template is declared `const` (
 [[class.mfct.non-static]]) if and only if the *lambda-expression*’s
 *parameter-declaration-clause* is not followed by `mutable`. It is
+neither virtual nor declared `volatile`. Any *exception-specification*
+specified on a *lambda-expression* applies to the corresponding function
+call operator or operator template. An *attribute-specifier-seq* in a
+*lambda-declarator* appertains to the type of the corresponding function
+call operator or operator template. Names referenced in the
+*lambda-declarator* are looked up in the context in which the
+*lambda-expression* appears.
+The closure type for a non-generic *lambda-expression* with no
+*lambda-capture* has a public non-virtual non-explicit const conversion
+function to pointer to function with C++language linkage ([[dcl.link]])
+having the same parameter and return types as the closure type’s
+function call operator. The value returned by this conversion function
+shall be the address of a function that, when invoked, has the same
+effect as invoking the closure type’s function call operator. For a
+generic lambda with no *lambda-capture*, the closure type has a public
+non-virtual non-explicit const conversion function template to pointer
+to function. The conversion function template has the same invented
+*template-parameter-list*, and the pointer to function has the same
+parameter types, as the function call operator template. The return type
+of the pointer to function shall behave as if it were a
+*decltype-specifier* denoting the return type of the corresponding
+function call operator template specialization. If the generic lambda
+has no *trailing-return-type* or the *trailing-return-type* contains a
+placeholder type, return type deduction of the corresponding function
+call operator template specialization has to be done. The corresponding
+specialization is that instantiation of the function call operator
+template with the same template arguments as those deduced for the
+conversion function template. Consider the following:
+``` cpp
+auto glambda = [](auto a) { return a; };
+int (*fp)(int) = glambda;
+```
+The behavior of the conversion function of `glambda` above is like that
+of the following conversion function:
+``` cpp
+struct Closure {
+  template<class T> auto operator()(T t) const { ... }
+  template<class T> static auto lambda_call_operator_invoker(T a) {
+    // forwards execution to operator()(a) and therefore has
+    // the same return type deduced
+    ...
+  }
+  template<class T> using fptr_t =
+     decltype(lambda_call_operator_invoker(declval<T>())) (*)(T);
+  template<class T> operator fptr_t<T>() const
+    { return &lambda_call_operator_invoker; }
+};
+```
+``` cpp
+void f1(int (*)(int))   { }
+void f2(char (*)(int))  { }
+void g(int (*)(int))    { }  // #1
+void g(char (*)(char))  { }  // #2
+void h(int (*)(int))    { }  // #3
+void h(char (*)(int))   { }  // #4
+auto glambda = [](auto a) { return a; };
+f1(glambda);  // OK
+f2(glambda);  // error: ID is not convertible
+g(glambda);   // error: ambiguous
+h(glambda);   // OK: calls #3 since it is convertible from ID
+int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK
+```
+The value returned by any given specialization of this conversion
+function template shall be the address of a function that, when invoked,
+has the same effect as invoking the generic lambda’s corresponding
+function call operator template specialization. This will result in the
+implicit instantiation of the generic lambda’s body. The instantiated
+generic lambda’s return type and parameter types shall match the return
+type and parameter types of the pointer to function.
+``` cpp
+auto GL = [](auto a) { std::cout << a; return a; };
+int (*GL_int)(int) = GL;  // OK: through conversion function template
+GL_int(3);                // OK: same as GL(3)
+```
 The *lambda-expression*’s *compound-statement* yields the
 *function-body* ([[dcl.fct.def]]) of the function call operator, but
 for purposes of name lookup ([[basic.lookup]]), determining the type
 and value of `this` ([[class.this]]) and transforming *id-expression*s
     };
   }
 };
 ```
+Further, a variable `__func__` is implicitly defined at the beginning of
+the *compound-statement* of the *lambda-expression*, with semantics as
+described in  [[dcl.fct.def.general]].
+If a *lambda-capture* includes a *capture-default* that is `&`, no
+identifier in a *simple-capture* of that *lambda-capture* shall be
+preceded by `&`. If a *lambda-capture* includes a *capture-default* that
+is `=`, each *simple-capture* of that *lambda-capture* shall be of the
+form “`&` *identifier*”. Ignoring appearances in *initializer*s of
+*init-capture*s, an identifier or `this` shall not appear more than once
+in a *lambda-capture*.
 ``` cpp
 struct S2 { void f(int i); };
 void S2::f(int i) {
   [&, i]{ };    // OK
   [i, i]{ };    // error: i repeated
 }
 ```
 A *lambda-expression* whose smallest enclosing scope is a block scope (
+[[basic.scope.block]]) is a *local lambda expression*; any other
+*lambda-expression* shall not have a *capture-default* or
+*simple-capture* in its *lambda-introducer*. The *reaching scope* of a
+local lambda expression is the set of enclosing scopes up to and
+including the innermost enclosing function and its parameters. This
+reaching scope includes any intervening *lambda-expression*s.
+The *identifier* in a *simple-capture* is looked up using the usual
 rules for unqualified name lookup ([[basic.lookup.unqual]]); each such
+lookup shall find an entity. An entity that is designated by a
+*simple-capture* is said to be *explicitly captured*, and shall be
+`this` or a variable with automatic storage duration declared in the
+reaching scope of the local lambda expression.
+An *init-capture* behaves as if it declares and explicitly captures a
+variable of the form “`auto` *init-capture* `;`” whose declarative
+region is the *lambda-expression*’s *compound-statement*, except that:
+- if the capture is by copy (see below), the non-static data member
+  declared for the capture and the variable are treated as two different
+  ways of referring to the same object, which has the lifetime of the
+  non-static data member, and no additional copy and destruction is
+  performed, and
+- if the capture is by reference, the variable’s lifetime ends when the
+  closure object’s lifetime ends.
+This enables an *init-capture* like “`x = std::move(x)`”; the second
+“`x`” must bind to a declaration in the surrounding context.
+``` cpp
+int x = 4;
+auto y = [&r = x, x = x+1]()->int {
+            r += 2;
+            return x+2;
+         }();  // Updates ::x to 6, and initializes y to 7.
+```
+A *lambda-expression* with an associated *capture-default* that does not
+explicitly capture `this` or a variable with automatic storage duration
+(this excludes any *id-expression* that has been found to refer to an
+*init-capture*'s associated non-static data member), is said to
+*implicitly capture* the entity (i.e., `this` or a variable) if the
+*compound-statement*:
+- odr-uses ([[basic.def.odr]]) the entity, or
+- names the entity in a potentially-evaluated expression (
+  [[basic.def.odr]]) where the enclosing full-expression depends on a
+  generic lambda parameter declared within the reaching scope of the
+  *lambda-expression*.
+``` cpp
+void f(int, const int (&)[2] = {})    { }   // #1
+void f(const int&, const int (&)[1])  { }   // #2
+void test() {
+  const int x = 17;
+  auto g = [](auto a) {
+    f(x);  // OK: calls #1, does not capture x
+  };
+  auto g2 = [=](auto a) {
+    int selector[sizeof(a) == 1 ? 1 : 2]{};
+    f(x, selector);  // OK: is a dependent expression, so captures x
+  };
+}
+```
+All such implicitly captured entities shall be declared within the
+reaching scope of the lambda expression. The implicit capture of an
+entity by a nested *lambda-expression* can cause its implicit capture by
+the containing *lambda-expression* (see below). Implicit odr-uses of
+`this` can result in implicit capture.
 An entity is *captured* if it is captured explicitly or implicitly. An
 entity captured by a *lambda-expression* is odr-used (
 [[basic.def.odr]]) in the scope containing the *lambda-expression*. If
 `this` is captured by a local lambda expression, its nearest enclosing
 function shall be a non-static member function. If a *lambda-expression*
+or an instantiation of the function call operator template of a generic
+lambda odr-uses ([[basic.def.odr]]) `this` or a variable with automatic
 storage duration from its reaching scope, that entity shall be captured
 by the *lambda-expression*. If a *lambda-expression* captures an entity
 and that entity is not defined or captured in the immediately enclosing
 lambda expression or function, the program is ill-formed.
 }
 ```
 An entity is *captured by copy* if it is implicitly captured and the
 *capture-default* is `=` or if it is explicitly captured with a capture
+that is not of the form `&` *identifier* or `&` *identifier*
+*initializer*. For each entity captured by copy, an unnamed non-static
+data member is declared in the closure type. The declaration order of
+these members is unspecified. The type of such a data member is the type
+of the corresponding captured entity if the entity is not a reference to
+an object, or the referenced type otherwise. If the captured entity is a
+reference to a function, the corresponding data member is also a
+reference to a function. A member of an anonymous union shall not be
+captured by copy.
 An entity is *captured by reference* if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional
 unnamed non-static data members are declared in the closure type for
+entities captured by reference. A member of an anonymous union shall not
+be captured by reference.
 If a *lambda-expression* `m2` captures an entity and that entity is
 captured by an immediately enclosing *lambda-expression* `m1`, then
 `m2`’s capture is transformed as follows:
 a = 2; b = 2; c = 2;
 m1();
 std::cout << a << b << c;
 ```
+Every *id-expression* within the *compound-statement* of a
+*lambda-expression* that is an odr-use ([[basic.def.odr]]) of an entity
+captured by copy is transformed into an access to the corresponding
+unnamed data member of the closure type. An *id-expression* that is not
+an odr-use refers to the original entity, never to a member of the
+closure type. Furthermore, such an *id-expression* does not cause the
+implicit capture of the entity. If `this` is captured, each odr-use of
+`this` is transformed into an access to the corresponding unnamed data
+member of the closure type, cast ([[expr.cast]]) to the type of `this`.
+The cast ensures that the transformed expression is a prvalue.
 ``` cpp
 void f(const int*);
 void g() {
   const int N = 10;
   [=] {
     int arr[N];             // OK: not an odr-use, refers to automatic variable
     f(&N);                  // OK: causes N to be captured; &N points to the
                             // corresponding member of the closure type
+  };
 }
 ```
 Every occurrence of `decltype((x))` where `x` is a possibly
 parenthesized *id-expression* that names an entity of automatic storage
 The closure type associated with a *lambda-expression* has an
 implicitly-declared destructor ([[class.dtor]]).
 When the *lambda-expression* is evaluated, the entities that are
 captured by copy are used to direct-initialize each corresponding
+non-static data member of the resulting closure object, and the
+non-static data members corresponding to the *init-capture*s are
+initialized as indicated by the corresponding *initializer* (which may
+be copy- or direct-initialization). (For array members, the array
+elements are direct-initialized in increasing subscript order.) These
+initializations are performed in the (unspecified) order in which the
+non-static data members are declared. This ensures that the destructions
+will occur in the reverse order of the constructions.
 If an entity is implicitly or explicitly captured by reference, invoking
 the function call operator of the corresponding *lambda-expression*
 after the lifetime of the entity has ended is likely to result in
 undefined behavior.
+A *simple-capture* followed by an ellipsis is a pack expansion (
+[[temp.variadic]]). An *init-capture* followed by an ellipsis is
+ill-formed.
 ``` cpp
 template<class... Args>
 void f(Args... args) {
   auto lm = [&, args...] { return g(args...); };
 `>{>}` token by two consecutive `>` tokens ([[temp.names]]).
 ### Subscripting <a id="expr.sub">[[expr.sub]]</a>
 A postfix expression followed by an expression in square brackets is a
+postfix expression. One of the expressions shall have the type “array of
+`T`” or “pointer to `T`” and the other shall have unscoped enumeration
+or integral type. The result is of type “`T`.” The type “`T`” shall be a
 completely-defined object type.[^5] The expression `E1[E2]` is identical
 (by definition) to `*((E1)+(E2))` see  [[expr.unary]] and  [[expr.add]]
+for details of `*` and `+` and  [[dcl.array]] for details of arrays. ,
+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 *braced-init-list* shall not be used with the built-in subscript
 operator.
 ### Function call <a id="expr.call">[[expr.call]]</a>
+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.
+The postfix expression shall have function type or pointer to function
+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
+it shall have pointer to function type. Calling a function through an
+expression whose function type has a language linkage that is different
+from the language linkage of the function type of the called function’s
+definition is undefined ([[dcl.link]]). For a call to a non-static
+member function, the postfix expression shall be an implicit (
+[[class.mfct.non-static]],  [[class.static]]) or explicit class member
+access ([[expr.ref]]) whose *id-expression* is a function member name,
+or a pointer-to-member expression ([[expr.mptr.oper]]) selecting a
+function member; the call is as a member of the class object referred to
+by the object expression. In the case of an implicit class member
+access, the implied object is the one pointed to by `this`. a member
+function call of the form `f()` is interpreted as `(*this).f()` (see
+[[class.mfct.non-static]]). If a function or member function name is
+used, the name can be overloaded (Clause  [[over]]), in which case the
+appropriate function shall be selected according to the rules in
+[[over.match]]. 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 *virtual function
+call*. 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.
 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.
 If the *postfix-expression* designates a destructor ([[class.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 `virtual` keyword), even if the type
+of the function actually called is different. This return type shall be
+an object type, a reference type or cv `void`.
 When a function is called, each parameter ([[dcl.fct]]) shall be
 initialized ([[dcl.init]],  [[class.copy]],  [[class.ctor]]) with its
 corresponding argument. Such initializations are indeterminately
 sequenced with respect to each other ([[intro.execution]]) If the
 [[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*.
+The evaluations of the postfix expression and of the arguments are all
+unsequenced relative to one another. All side effects of argument
+evaluations are sequenced before the function is entered (see
+[[intro.execution]]).
+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.
 prvalue.
 The expression `T()`, where `T` is a *simple-type-specifier* or
 *typename-specifier* for a non-array complete object type or the
 (possibly cv-qualified) `void` type, creates a prvalue of the specified
+type, whose value is that produced by value-initializing ([[dcl.init]])
+an object of type `T`; no initialization is done for the `void()` case.
+if `T` is a non-class type that is cv-qualified, the *cv-qualifier*s are
+discarded when determining the type of the resulting prvalue (Clause
+[[expr]]).
 Similarly, a *simple-type-specifier* or *typename-specifier* followed by
 a *braced-init-list* creates a temporary object of the specified type
 direct-list-initialized ([[dcl.init.list]]) with the specified
 *braced-init-list*, and its value is that temporary object as a prvalue.
 ### 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` ([[temp.names]]), and then followed
 by an *id-expression*, is a postfix expression. The postfix expression
+before the dot or arrow is evaluated;[^6] the result of that evaluation,
 together with the *id-expression*, determines the result of the entire
 postfix expression.
 For the first option (dot) the first expression shall have complete
 class type. For the second option (arrow) the first expression shall
 have pointer to complete class 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).[^7] In either
 case, the *id-expression* shall name a member of the class or of one of
 its base classes. because the name of a class is inserted in its class
 scope (Clause  [[class]]), the name of a class is also considered a
 nested member of that class. [[basic.lookup.classref]] describes how
 names are looked up after the `.` and `->` operators.
   `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 named member 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 a (possibly overloaded) member function, function overload
   resolution ([[over.match]]) is used to determine whether `E1.E2`
   refers to a static or a non-static member function.
   - If it refers to a static member function and the type of `E2` is
     “function of parameter-type-list returning `T`”, then `E1.E2` is an
 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`. 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`. [^8] The result is an lvalue if `T` is an
 lvalue reference, or an xvalue if `T` is an rvalue reference. In both
 the pointer and reference cases, the program is ill-formed if *cv2* has
 greater cv-qualification than *cv1* or if `B` is an inaccessible or
 ambiguous base class of `D`.
 void foo(D* dp) {
   B*  bp = dynamic_cast<B*>(dp);    // equivalent to B* bp = dp;
 }
 ```
+Otherwise, `v` shall be a pointer to or a glvalue of a polymorphic
 type ([[class.virtual]]).
 If `T` is “pointer to *cv* `void`,” then the result is a pointer to the
 most derived object pointed to by `v`. Otherwise, a run-time check is
 applied to see if the object pointed or referred to by `v` can be
   result points (refers) to the `C` subobject of the most derived
   object.
 - Otherwise, the run-time check *fails*.
 The value of a failed cast to pointer type is the null pointer value of
+the required result type. A failed cast to reference type throws an
+exception ([[except.throw]]) of a type that would match a handler (
+[[except.handle]]) of type `std::bad_cast` ([[bad.cast]]).
 ``` cpp
 class A { virtual void f(); };
 class B { virtual void g(); };
 class D : public virtual A, private B { };
 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]].[^9] 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.
 When `typeid` is applied to a glvalue expression 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 expression is obtained by applying the
+unary `*` operator to a pointer[^10] and the pointer is a null pointer
+value ([[conv.ptr]]), 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 (
 the result of the `typeid` expression refers to a `std::type_info`
 object representing the *cv*-unqualified referenced type. If the type of
 the *type-id* is a class type or a reference to a class type, the class
 shall be completely-defined.
+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.
 ``` cpp
 class D { /* ... */ };
 D d1;
 const D d2;
 virtual base class of `D`. The result has type “*cv2* `D`.” An xvalue of
 type “*cv1* `B`” may be cast to type “rvalue reference to *cv2* `D`”
 with the same constraints as for an lvalue of type “*cv1* `B`.” If the
 object of type “*cv1* `B`” is actually a subobject of an object of type
 `D`, the result refers to the enclosing object of type `D`. Otherwise,
+the behavior is undefined.
 ``` cpp
 struct B { };
 struct D : public B { };
 D d;
 B &br = d;
 static_cast<D&>(br);            // produces lvalue to the original d object
 ```
+A glvalue, class prvalue, or array prvalue of type “*cv1* `T1`” can be
+cast to type “rvalue reference to *cv2* `T2`” if “*cv2* `T2`” is
+reference-compatible with “*cv1* `T1`” ([[dcl.init.ref]]). If the value
+is not a bit-field, the result refers to the object or the specified
+base class subobject thereof; otherwise, the lvalue-to-rvalue
+conversion ([[conv.lval]]) is applied to the bit-field and the
+resulting prvalue is used as the *expression* of the `static_cast` for
+the remainder of this section. If `T2` is an inaccessible (Clause
 [[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` using a
+`static_cast` of the form `static_cast<T>(e)` if the declaration
 `T t(e);` is well-formed, for some invented temporary variable `t` (
 [[dcl.init]]). The effect of such an explicit conversion is the same as
 performing the declaration and initialization and then using the
 temporary variable as the result of the conversion. The expression `e`
 is used as a glvalue if and only if the initialization uses it as a
 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. When that type is cv `bool`, the
+resulting value is `false` if the original value is zero and `true` for
+all other values. For the remaining integral types, the value is
+unchanged if the original value can be represented by the specified
+type. Otherwise, the resulting value is unspecified. A value of a scoped
+enumeration type can also be explicitly converted to a floating-point
+type; the result is the same as that of converting from the original
+value to the floating-point type.
 A value of integral or enumeration type can be explicitly converted to
 an enumeration type. The value is unchanged if the original value is
 within the range of the enumeration values ([[dcl.enum]]). Otherwise,
 the resulting value is unspecified (and might not be in that range). A
+value of floating-point type can also be explicitly converted to an
+enumeration type. The resulting value is the same as converting the
+original value to the underlying type of the enumeration (
+[[conv.fpint]]), and subsequently to the enumeration type.
 A prvalue of type “pointer to *cv1* `B`,” where `B` is a class type, can
 be converted to a prvalue of type “pointer to *cv2* `D`,” where `D` is a
 class derived (Clause  [[class.derived]]) from `B`, if a valid standard
 conversion from “pointer to `D`” to “pointer to `B`” exists (
 `D` nor a base class of a virtual base class of `D`. The null pointer
 value ([[conv.ptr]]) is converted to the null pointer value of the
 destination type. If the prvalue of type “pointer to *cv1* `B`” points
 to a `B` that is actually a subobject of an object of type `D`, the
 resulting pointer points to the enclosing object of type `D`. Otherwise,
+the behavior is undefined.
 A prvalue of type “pointer to member of `D` of type *cv1* `T`” can be
 converted to a prvalue of type “pointer to member of `B`” of type *cv2*
 `T`, where `B` is a base class (Clause  [[class.derived]]) of `D`, if a
 valid standard conversion from “pointer to member of `B` of type `T`” to
 “pointer to member of `D` of type `T`” exists ([[conv.mem]]), and *cv2*
 is the same cv-qualification as, or greater cv-qualification than,
+*cv1*.[^11] 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. 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]].
 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*. The null pointer value is converted to the null pointer value of
+the destination type. If the original pointer value represents the
+address `A` of a byte in memory and `A` satisfies the alignment
+requirement of `T`, then the resulting pointer value represents the same
+address as the original pointer value, that is, `A`. The result of any
+other such pointer conversion is unspecified. A value of type pointer to
+object converted to “pointer to *cv* `void`” and back, possibly with
+different cv-qualification, shall have its original value.
 ``` 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.
 the original pointer value, the result of such a pointer conversion is
 unspecified. see also  [[conv.ptr]] for more details of pointer
 conversions.
 An object pointer can be explicitly converted to an object pointer of a
+different type.[^12] 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))`. Converting a prvalue of
+type “pointer to `T1`” to the type “pointer to `T2`” (where `T1` and
+`T2` are object types and where the alignment requirements of `T2` are
+no stricter than those of `T1`) and back to its original type yields the
+original pointer value.
 Converting a function pointer to an object pointer type or vice versa is
 conditionally-supported. The meaning of such a conversion is
 *implementation-defined*, except that if an implementation supports
 conversions in both directions, converting a prvalue of one type to the
 pointer value.
 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.[^13] 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:
 - converting a prvalue of type “pointer to member function” to a
   different pointer to member function type and back to its original
   `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 expression of type `T1` 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 refers to the same object as the source glvalue, but with the
+specified type. That is, for lvalues, a reference cast
+`reinterpret_cast<T&>(x)` has the same effect as the conversion
+`*reinterpret_cast<T*>(&x)` with the built-in `&` and `*` operators (and
+similarly for `reinterpret_cast<T&&>(x)`). No temporary is created, no
+copy is made, and constructors ([[class.ctor]]) or conversion
+functions ([[class.conv]]) are not called.[^14]
 ### 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`
 [[conv.mem]]) is converted to the null member pointer value of the
 destination type.
 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[^15] may produce undefined behavior (
 [[dcl.type.cv]]).
 The following rules define the process known as *casting away
 constness*. In these rules `Tn ` and `Xn ` represent types. For two
 pointer types:
 The unary `*` operator performs *indirection*: the expression to which
 it is applied shall be a pointer to an object type, or a pointer to a
 function type and the result is an lvalue referring to the object or
 function to which the expression points. If the type of the expression
+is “pointer to `T`,” the type of the result is “`T`.” indirection
+through a pointer to an incomplete type (other than *cv* `void`) is
+valid. The lvalue thus obtained can be used in limited ways (to
+initialize a reference, for example); this lvalue must not be converted
+to a prvalue, see  [[conv.lval]].
 The result of each of the following unary operators is a prvalue.
 The result of the unary `&` operator is a pointer to its operand. The
 operand shall be an lvalue or a *qualified-id*. If the operand is a
 “pointer to member function” as there is from an lvalue of function type
 to the type “pointer to function” ([[conv.func]]). Nor is
 `&unqualified-id` a pointer to member, even within the scope of the
 *unqualified-id*’s class.
+If `&` is applied to an lvalue of incomplete class type and the complete
+type declares `operator&()`, it is unspecified whether the operator has
+the built-in meaning or the operator function is called. The operand of
+`&` shall not be a bit-field.
 The address of an overloaded function (Clause  [[over]]) can be taken
 only in a context that uniquely determines which version of the
 overloaded function is referred to (see  [[over.over]]). since the
 context might determine whether the operand is a static or non-static
 representation of its operand. The operand is either an expression,
 which is an unevaluated operand (Clause  [[expr]]), or a parenthesized
 *type-id*. The `sizeof` operator shall not be applied to an expression
 that has function or incomplete type, to an enumeration type whose
 underlying type is not fixed before all its enumerators have been
+declared, to the parenthesized name of such types, or to a glvalue that
 designates a bit-field. `sizeof(char)`, `sizeof(signed char)` and
 `sizeof(unsigned char)` are `1`. The result of `sizeof` applied to any
 other fundamental type ([[basic.fundamental]]) is
 *implementation-defined*. in particular, `sizeof(bool)`,
 `sizeof(char16_t)`, `sizeof(char32_t)`, and `sizeof(wchar_t)` are
+implementation-defined.[^16] See  [[intro.memory]] for the definition of
 *byte* and  [[basic.types]] for the definition of *object
 representation*.
 When applied to a reference or a reference type, the result is the size
 of the referenced type. When applied to a class, the result is the
 number of bytes in an object of that class including any padding
 required for placing objects of that type in an array. The size of a
 most derived class shall be greater than zero ([[intro.object]]). The
 result of applying `sizeof` to a base class subobject is the size of the
+base class type.[^17] When applied to an array, the result is the total
 number of bytes in the array. This implies that the size of an array of
 *n* elements is *n* times the size of an element.
 The `sizeof` operator can be applied to a pointer to a function, but
 shall not be applied directly to a function.
 initial element (if any) of the array. both `new int` and `new int[10]`
 have type `int*` and the type of `new int[i][10]` is `int (*)[10]` The
 *attribute-specifier-seq* in a *noptr-new-declarator* appertains to the
 associated array type.
+Every *constant-expression* in a *noptr-new-declarator* shall be a
+converted constant expression ([[expr.const]]) of type `std::size_t`
+and shall evaluate to a strictly positive value. The *expression* in a
+*noptr-new-declarator*is implicitly converted to `std::size_t`. given
+the definition `int n = 42`, `new float[n][5]` is well-formed (because
+`n` is the *expression* of a *noptr-new-declarator*), but
+`new float[5][n]` is ill-formed (because `n` is not a constant
+expression).
+The *expression* in a *noptr-new-declarator* is erroneous if:
+- the expression is of non-class type and its value before converting to
+  `std::size_t` is less than zero;
+- the expression is of class type and its value before application of
+  the second standard conversion ([[over.ics.user]])[^18] is less than
+  zero;
+- its value is such that the size of the allocated object would exceed
+  the implementation-defined limit (annex  [[implimits]]); or
+- the *new-initializer* is a *braced-init-list* and the number of array
+  elements for which initializers are provided (including the
+  terminating `'\0'` in a string literal ([[lex.string]])) exceeds the
+  number of elements to initialize.
+If the *expression*, after converting to `std::size_t`, is a core
+constant expression and the expression is erroneous, the program is
+ill-formed. Otherwise, a *new-expression* with an erroneous expression
+does not call an allocation function and terminates by throwing an
+exception of a type that would match a handler ([[except.handle]]) of
+type `std::bad_array_new_length` ([[new.badlength]]). When the value of
+the *expression* is zero, the allocation function is called to allocate
+an array with no elements.
+A *new-expression* may obtain storage for the object by calling an
 *allocation function* ([[basic.stc.dynamic.allocation]]). If the
 *new-expression* terminates by throwing an exception, it may release
 storage by calling a deallocation function (
 [[basic.stc.dynamic.deallocation]]). If the allocated type is a
 non-array type, the allocation function’s name is `operator new` and the
 if the allocated type is a class type `T` or array thereof, the
 allocation function’s name is looked up in the scope of `T`. If this
 lookup fails to find the name, or if the allocated type is not a class
 type, the allocation function’s name is looked up in the global scope.
+An implementation is allowed to omit a call to a replaceable global
+allocation function ([[new.delete.single]], [[new.delete.array]]). When
+it does so, the storage is instead provided by the implementation or
+provided by extending the allocation of another *new-expression*. The
+implementation may extend the allocation of a *new-expression* `e1` to
+provide storage for a *new-expression* `e2` if the following would be
+true were the allocation not extended:
+- the evaluation of `e1` is sequenced before the evaluation of `e2`, and
+- `e2` is evaluated whenever `e1` obtains storage, and
+- both `e1` and `e2` invoke the same replaceable global allocation
+  function, and
+- if the allocation function invoked by `e1` and `e2` is throwing, any
+  exceptions thrown in the evaluation of either `e1` or `e2` would be
+  first caught in the same handler, and
+- the pointer values produced by `e1` and `e2` are operands to evaluated
+  *delete-expression*s, and
+- the evaluation of `e2` is sequenced before the evaluation of the
+  *delete-expression* whose operand is the pointer value produced by
+  `e1`.
+``` cpp
+void mergeable(int x) {
+    // These allocations are safe for merging:
+    std::unique_ptr<char[]> a{new (std::nothrow) char[8]};
+    std::unique_ptr<char[]> b{new (std::nothrow) char[8]};
+    std::unique_ptr<char[]> c{new (std::nothrow) char[x]};
+    g(a.get(), b.get(), c.get());
+  }
+  void unmergeable(int x) {
+    std::unique_ptr<char[]> a{new char[8]};
+    try {
+      // Merging this allocation would change its catch handler.
+      std::unique_ptr<char[]> b{new char[x]};
+    } catch (const std::bad_alloc& e) {
+      std::cerr << "Allocation failed: " << e.what() << std::endl;
+      throw;
+    }
+  }
+```
+When a *new-expression* calls an allocation function and that allocation
+has not been extended, the *new-expression* passes the amount of space
+requested to the allocation function as the first argument of type
+`std::size_t`. That argument shall be no less than the size of the
+object being created; it may be greater than the size of the object
+being created only if the object is an array. For arrays of `char` and
+`unsigned char`, the difference between the result of the
+*new-expression* and the address returned by the allocation function
+shall be an integral multiple of the strictest fundamental alignment
+requirement ([[basic.align]]) of any object type whose size is no
+greater than the size of the array being created. Because allocation
+functions are assumed to return pointers to storage that is
+appropriately aligned for objects of any type with fundamental
+alignment, this constraint on array allocation overhead permits the
+common idiom of allocating character arrays into which objects of other
+types will later be placed.
+When a *new-expression* calls an allocation function and that allocation
+has been extended, the size argument to the allocation call shall be no
+greater than the sum of the sizes for the omitted calls as specified
+above, plus the size for the extended call had it not been extended,
+plus any padding necessary to align the allocated objects within the
+allocated memory.
 The *new-placement* syntax is used to supply additional arguments to an
 allocation function. If used, overload resolution is performed on a
 function call created by assembling an argument list consisting of the
 amount of space requested (the first argument) and the expressions in
 A *new-expression* that creates an object of type `T` initializes that
 object as follows:
 - If the *new-initializer* is omitted, the object is
+  default-initialized ([[dcl.init]]). If no initialization is
+  performed, the object has an indeterminate value.
 - Otherwise, the *new-initializer* is interpreted according to the
   initialization rules of  [[dcl.init]] for direct-initialization.
 The invocation of the allocation function is indeterminately sequenced
 with respect to the evaluations of expressions in the *new-initializer*.
 function returns the null pointer or exits using an exception.
 If the *new-expression* creates an object or an array of objects of
 class type, access and ambiguity control are done for the allocation
 function, the deallocation function ([[class.free]]), and the
+constructor ([[class.ctor]]). If the *new-expression* creates an array
+of objects of class type, the destructor is potentially invoked (
+[[class.dtor]]).
 If any part of the object initialization described above[^19] terminates
+by throwing an exception, storage has been obtained for the object, and
+a suitable deallocation function can be found, the deallocation function
+is called to free the memory in which the object was being constructed,
+after which the exception continues to propagate in the context of the
+*new-expression*. If no unambiguous matching deallocation function can
+be found, propagating the exception does not cause the object’s memory
+to be freed. This is appropriate when the called allocation function
+does not allocate memory; otherwise, it is likely to result in a memory
+leak.
 If the *new-expression* begins with a unary `::` operator, the
 deallocation function’s name is looked up in the global scope.
 Otherwise, if the allocated type is a class type `T` or an array
 thereof, the deallocation function’s name is looked up in the scope of
 looked up in the global scope.
 A declaration of a placement deallocation function matches the
 declaration of a placement allocation function if it has the same number
 of parameters and, after parameter transformations ([[dcl.fct]]), all
+parameter types except the first are identical. If the lookup finds a
+single matching deallocation function, that function will be called;
+otherwise, no deallocation function will be called. If the lookup finds
+the two-parameter form of a usual deallocation function (
+[[basic.stc.dynamic.deallocation]]) and that function, considered as a
+placement deallocation function, would have been selected as a match for
+the allocation function, the program is ill-formed. For a non-placement
+allocation function, the normal deallocation function lookup is used to
+find the matching deallocation function ([[expr.delete]])
 ``` cpp
 struct S {
   // Placement allocation function:
   static void* operator new(std::size_t, std::size_t);
 ```
 The first alternative is for non-array objects, and the second is for
 arrays. Whenever the `delete` keyword is immediately followed by empty
 square brackets, it shall be interpreted as the second alternative.[^20]
+The operand shall be of pointer to object type or of class type. If of
+class type, the operand is contextually implicitly converted (Clause
+[[conv]]) to a pointer to object type.[^21] The *delete-expression*’s
+result has type `void`.
 If the operand has a class type, the operand is converted to a pointer
 type by calling the above-mentioned conversion function, and the
 converted operand is used in place of the original operand for the
 remainder of this section. In the first alternative (*delete object*),
 case of an array, the elements will be destroyed in order of decreasing
 address (that is, in reverse order of the completion of their
 constructor; see  [[class.base.init]]).
 If the value of the operand of the *delete-expression* is not a null
+pointer value, then:
+- If the allocation call for the *new-expression* for the object to be
+  deleted was not omitted and the allocation was not extended (
+  [[expr.new]]), the *delete-expression* shall call a deallocation
+  function ([[basic.stc.dynamic.deallocation]]). The value returned
+  from the allocation call of the *new-expression* shall be passed as
+  the first argument to the deallocation function.
+- Otherwise, if the allocation was extended or was provided by extending
+  the allocation of another *new-expression*, and the
+  *delete-expression* for every other pointer value produced by a
+  *new-expression* that had storage provided by the extended
+  *new-expression* has been evaluated, the *delete-expression* shall
+  call a deallocation function. The value returned from the allocation
+  call of the extended *new-expression* shall be passed as the first
+  argument to the deallocation function.
+- Otherwise, the *delete-expression* will not call a *deallocation
+  function* ([[basic.stc.dynamic.deallocation]]).
+Otherwise, it is unspecified whether the deallocation function will be
+called. The deallocation function is called regardless of whether the
+destructor for the object or some element of the array throws an
+exception.
 An implementation provides default definitions of the global
 deallocation functions `operator delete()` for non-arrays (
 [[new.delete.single]]) and `operator delete[]()` for arrays (
 [[new.delete.array]]). A C++ program can provide alternative definitions
 of these functions ([[replacement.functions]]), and/or class-specific
 versions ([[class.free]]).
 When the keyword `delete` in a *delete-expression* is preceded by the
+unary `::` operator, the deallocation function’s name is looked up in
+global scope. Otherwise, the lookup considers class-specific
+deallocation functions ([[class.free]]). If no class-specific
+deallocation function is found, the deallocation function’s name is
+looked up in global scope.
+If the type is complete and if deallocation function lookup finds both a
+usual deallocation function with only a pointer parameter and a usual
+deallocation function with both a pointer parameter and a size
+parameter, then the selected deallocation function shall be the one with
+two parameters. Otherwise, the selected deallocation function shall be
+the function with one parameter.
+When a *delete-expression* is executed, the selected deallocation
+function shall be called with the address of the block of storage to be
+reclaimed as its first argument and (if the two-parameter deallocation
+function is used) the size of the block as its second argument.[^23]
 Access and ambiguity control are done for both the deallocation function
 and the destructor ([[class.dtor]],  [[class.free]]).
 ### Alignof <a id="expr.alignof">[[expr.alignof]]</a>
 An `alignof` expression yields the alignment requirement of its operand
 type. The operand shall be a *type-id* representing a complete object
+type, or an array thereof, or a reference to one of those types.
 The result is an integral constant of type `std::size_t`.
+When `alignof` is applied to a reference type, the result is the
 alignment of the referenced type. When `alignof` is applied to an array
+type, the result is the alignment of the element type.
 ### `noexcept` operator <a id="expr.unary.noexcept">[[expr.unary.noexcept]]</a>
 The `noexcept` operator determines whether the evaluation of its
 operand, which is an unevaluated operand (Clause  [[expr]]), can throw
 noexcept-expression:
   'noexcept' '(' expression ')'
 ```
 The result of the `noexcept` operator is a constant of type `bool` and
+is a prvalue.
 The result of the `noexcept` operator is `false` if in a
 potentially-evaluated context the *expression* would contain
+- a potentially-evaluated call[^24] to a function, member function,
   function pointer, or member function pointer that does not have a
   non-throwing *exception-specification* ([[except.spec]]), unless the
   call is a constant expression ([[expr.const]]),
+- a potentially-evaluated *throw-expression* ([[except.throw]]),
+- a potentially-evaluated `dynamic_cast` expression
   `dynamic_cast<T>(v)`, where `T` is a reference type, that requires a
   run-time check ([[expr.dynamic.cast]]), or
+- a potentially-evaluated `typeid` expression ([[expr.typeid]]) applied
   to a glvalue expression whose type is a polymorphic class type (
   [[class.virtual]]).
 Otherwise, the result is `true`.
 The result of the expression `(T)` *cast-expression* is of type `T`. The
 result is an lvalue if `T` is an lvalue reference type or an rvalue
 reference to function type and an xvalue if `T` is an rvalue reference
 to object type; otherwise the result is a prvalue. if `T` is a non-class
+type that is cv-qualified, the *cv-qualifiers* are discarded when
+determining the type of the resulting prvalue; see Clause  [[expr]].
 An explicit type conversion can be expressed using functional notation (
 [[expr.type.conv]]), a type conversion operator (`dynamic_cast`,
 `static_cast`, `reinterpret_cast`, `const_cast`), or the *cast*
 notation.
     pm-expression '.*' cast-expression
     pm-expression '->*' cast-expression
 ```
 The binary operator `.*` binds its second operand, which shall be of
+type “pointer to member of `T`” to its first operand, which shall be of
+class `T` or of a class of which `T` is an unambiguous and accessible
+base class. The result is an object or a function of the type specified
+by the second operand.
 The binary operator `->*` binds its second operand, which shall be of
+type “pointer to member of `T`” to its first operand, which shall be of
+type “pointer to `T`” or “pointer to a class of which `T` is an
+unambiguous and accessible base class.” The expression `E1->*E2` is
+converted into the equivalent form `(*(E1)).*E2`.
 Abbreviating *pm-expression*`.*`*cast-expression* as `E1.*E2`, `E1` is
 called the *object expression*. If the dynamic type of `E1` does not
 contain the member to which `E2` refers, the behavior is undefined.
 is an rvalue, the program is ill-formed if the second operand is a
 pointer to member function with *ref-qualifier* `&`. In a `.*`
 expression whose object expression is an lvalue, the program is
 ill-formed if the second operand is a pointer to member function with
 *ref-qualifier* `&&`. The result of a `.*` expression whose second
+operand is a pointer to a data member is an lvalue if the first operand
+is an lvalue and an xvalue otherwise. The result of a `.*` expression
 whose second operand is a pointer to a member function is a prvalue. If
 the second operand is the null pointer to member value ([[conv.mem]]),
 the behavior is undefined.
 ## Multiplicative operators <a id="expr.mul">[[expr.mul]]</a>
 The binary `/` operator yields the quotient, and the binary `%` operator
 yields the remainder from the division of the first expression by the
 second. If the second operand of `/` or `%` is zero the behavior is
 undefined. For integral operands the `/` operator yields the algebraic
+quotient with any fractional part discarded;[^25] if the quotient `a/b`
 is representable in the type of the result, `(a/b)*b + a%b` is equal to
+`a`; otherwise, the behavior of both `a/b` and `a%b` is undefined.
 ## Additive operators <a id="expr.add">[[expr.add]]</a>
 The additive operators `+` and `-` group left-to-right. The usual
 arithmetic conversions are performed for operands of arithmetic or
 `-((P)-((Q)+1))`, and has the value zero if the expression `P` points
 one past the last element of the array object, even though the
 expression `(Q)+1` does not point to an element of the array object.
 Unless both pointers point to elements of the same array object, or one
 past the last element of the array object, the behavior is
+undefined.[^26]
+For addition or subtraction, if the expressions `P` or `Q` have type
+“pointer to cv `T`”, where `T` is different from the cv-unqualified
+array element type, the behavior is undefined. In particular, a pointer
+to a base class cannot be used for pointer arithmetic when the array
+contains objects of a derived class type.
 If the value 0 is added to or subtracted from a pointer value, the
 result compares equal to the original pointer value. If two pointers
 point to the same object or both point one past the end of the same
 array or both are null, and the two pointers are subtracted, the result
 The value of `E1 << E2` is `E1` left-shifted `E2` bit positions; vacated
 bits are zero-filled. If `E1` has an unsigned type, the value of the
 result is $\mathrm{E1}\times2^\mathrm{E2}$, reduced modulo one more than
 the maximum value representable in the result type. Otherwise, if `E1`
 has a signed type and non-negative value, and
+$\mathrm{E1}\times2^\mathrm{E2}$ is representable in the corresponding
+unsigned type of the result type, then that value, converted to the
+result type, is the resulting value; otherwise, the behavior is
+undefined.
 The value of `E1 >> E2` is `E1` right-shifted `E2` bit positions. If
 `E1` has an unsigned type or if `E1` has a signed type and a
 non-negative value, the value of the result is the integral part of the
 quotient of $\mathrm{E1}/2^\mathrm{E2}$. If `E1` has a signed type and a
     relational-expression '>' shift-expression
     relational-expression '<=' shift-expression
     relational-expression '>=' shift-expression
 ```
+The operands shall have arithmetic, enumeration, or pointer type. The
+operators `<` (less than), `>` (greater than), `<=` (less than or equal
+to), and `>=` (greater than or equal to) all yield `false` or `true`.
+The type of the result is `bool`.
 The usual arithmetic conversions are performed on operands of arithmetic
+or enumeration type. If both operands are pointers, pointer
+conversions ([[conv.ptr]]) and qualification conversions (
+[[conv.qual]]) are performed to bring them to their composite pointer
+type (Clause  [[expr]]). After conversions, the operands shall have the
+same type.
+Comparing pointers to objects is defined as follows:
+- If two pointers point to different elements of the same array, or to
+  subobjects thereof, the pointer to the element with the higher
+  subscript compares greater.
+- If one pointer points to an element of an array, or to a subobject
+  thereof, and another pointer points one past the last element of the
+  array, the latter pointer compares greater.
+- If two pointers point to different non-static data members of the same
+  object, or to subobjects of such members, recursively, the pointer to
+  the later declared member compares greater provided the two members
+  have the same access control (Clause  [[class.access]]) and provided
+  their class is not a union.
+If two operands `p` and `q` compare equal ([[expr.eq]]), `p<=q` and
+`p>=q` both yield `true` and `p<q` and `p>q` both yield `false`.
+Otherwise, if a pointer `p` compares greater than a pointer `q`, `p>=q`,
+`p>q`, `q<=p`, and `q<p` all yield `true` and `p<=q`, `p<q`, `q>=p`, and
+`q>p` all yield `false`. Otherwise, the result of each of the operators
+is unspecified.
 If both operands (after conversions) are of arithmetic or enumeration
 type, each of the operators shall yield `true` if the specified
 relationship is true and `false` if it is false.
     relational-expression
     equality-expression '==' relational-expression
     equality-expression '!=' relational-expression
 ```
+The `==` (equal to) and the `!=` (not equal to) operators group
+left-to-right. The operands shall have arithmetic, enumeration, pointer,
+or pointer to member type, or type `std::nullptr_t`. The operators `==`
+and `!=` both yield `true` or `false`, i.e., a result of type `bool`. In
+each case below, the operands shall have the same type after the
+specified conversions have been applied.
+If at least one of the operands is a pointer, pointer conversions (
+[[conv.ptr]]) and qualification conversions ([[conv.qual]]) are
+performed on both operands to bring them to their composite pointer type
+(Clause  [[expr]]). Comparing pointers is defined as follows: Two
+pointers compare equal if they are both null, both point to the same
+function, or both represent the same address ([[basic.compound]]),
+otherwise they compare unequal.
+If at least one of the operands is a pointer to member, pointer to
+member conversions ([[conv.mem]]) and qualification conversions (
+[[conv.qual]]) are performed on both operands to bring them to their
+composite pointer type (Clause  [[expr]]). Comparing pointers to members
+is defined as follows:
+- If two pointers to members are both the null member pointer value,
+  they compare equal.
+- If only one of two pointers to members is the null member pointer
+  value, they compare unequal.
+- If either is a pointer to a virtual member function, the result is
+  unspecified.
+- If one refers to a member of class `C1` and the other refers to a
+  member of a different class `C2`, where neither is a base class of the
+  other, the result is unspecified.
+  ``` cpp
+  struct A {};
+  struct B : A { int x; };
+  struct C : A { int x; };
+  int A::*bx = (int(A::*))&B::x;
+  int A::*cx = (int(A::*))&C::x;
+  bool b1 = (bx == cx);   // unspecified
+  ```
+- Otherwise, two pointers to members compare equal if they would refer
+  to the same member of the same most derived object ([[intro.object]])
+  or the same subobject if indirection with a hypothetical object of the
+  associated class type were performed, otherwise they compare unequal.
   ``` cpp
   struct B {
     int f();
   };
   struct L : B { };
   int (L::*pl)() = pb;
   int (R::*pr)() = pb;
   int (D::*pdl)() = pl;
   int (D::*pdr)() = pr;
   bool x = (pdl == pdr);          // false
+  bool y = (pb == pl);            // true
   ```
+Two operands of type `std::nullptr_t` or one operand of type
+`std::nullptr_t` and the other a null pointer constant compare equal.
+If two operands compare equal, the result is `true` for the `==`
+operator and `false` for the `!=` operator. If two operands compare
+unequal, the result is `false` for the `==` operator and `true` for the
+`!=` operator. Otherwise, the result of each of the operators is
+unspecified.
+If both operands are of arithmetic or enumeration type, the usual
+arithmetic conversions are performed on both operands; each of the
+operators shall yield `true` if the specified relationship is true and
+`false` if it is false.
 ## Bitwise AND operator <a id="expr.bit.and">[[expr.bit.and]]</a>
 ``` bnf
 and-expression:
     inclusive-or-expression
     logical-and-expression '&&' inclusive-or-expression
 ```
 The `&&` operator groups left-to-right. The operands are both
+contextually converted to `bool` (Clause  [[conv]]). The result is
 `true` if both operands are `true` and `false` otherwise. Unlike `&`,
 `&&` guarantees left-to-right evaluation: the second operand is not
 evaluated if the first operand is `false`.
 The result is a `bool`. If the second expression is evaluated, every
 one of the second and third expressions is evaluated. Every value
 computation and side effect associated with the first expression is
 sequenced before every value computation and side effect associated with
 the second or third expression.
+If either the second or the third operand has type `void`, one of the
+following shall hold:
+- The second or the third operand (but not both) is a (possibly
+ parenthesized) *throw-expression* ([[except.throw]]); the result is
+ of the type and value category of the other.
 - Both the second and the third operands have type `void`; the result is
   of type `void` and is a prvalue. This includes the case where both
   operands are *throw-expression*s.
 Otherwise, if the second and third operand have different types and
   reference to `T2`”, subject to the constraint that in the conversion
   the reference must bind directly ([[dcl.init.ref]]) to an lvalue.
 - If `E2` is an xvalue: `E1` can be converted to match `E2` if `E1` can
   be implicitly converted to the type “rvalue reference to `T2`”,
   subject to the constraint that the reference must bind directly.
+- If `E2` is a prvalue or if neither of the conversions above can be
   done and at least one of the operands has (possibly cv-qualified)
   class type:
   - if `E1` and `E2` have class type, and the underlying class types are
     the same or one is a base class of the other: `E1` can be converted
     to match `E2` if the class of `T2` is the same type as, or a base
     match `E2` if `E1` can be implicitly converted to the type that
     expression `E2` would have if `E2` were converted to a prvalue (or
     the type it has, if `E2` is a prvalue).
 Using this process, it is determined whether the second operand can be
+converted to match the third operand, and whether the third operand can
+be converted to match the second operand. If both can be converted, or
+one can be converted but the conversion is ambiguous, the program is
+ill-formed. If neither can be converted, the operands are left unchanged
+and further checking is performed as described below. If exactly one
+conversion is possible, that conversion is applied to the chosen operand
+and the converted operand is used in place of the original operand for
+the remainder of this section.
 If the second and third operands are glvalues of the same value category
 and have the same type, the result is of that type and value category
 and it is a bit-field if the second or the third operand is a bit-field,
 or if both are bit-fields.
   the second operand or the third operand depending on the value of the
   first operand.
 - The second and third operands have arithmetic or enumeration type; the
   usual arithmetic conversions are performed to bring them to a common
   type, and the result is of that type.
+- One or both of the second and third operands have pointer type;
+  pointer conversions ([[conv.ptr]]) and qualification conversions (
   [[conv.qual]]) are performed to bring them to their composite pointer
+  type (Clause  [[expr]]). The result is of the composite pointer type.
+- One or both of the second and third operands have pointer to member
+ type; pointer to member conversions ([[conv.mem]]) and qualification
+  conversions ([[conv.qual]]) are performed to bring them to their
+ composite pointer type (Clause  [[expr]]). The result is of the
+ composite pointer type.
+- Both the second and third operands have type `std::nullptr_t` or one
+ has that type and the other is a null pointer constant. The result is
+  of type `std::nullptr_t`.
 ## Assignment and compound assignment operators <a id="expr.ass">[[expr.ass]]</a>
 The assignment operator (`=`) and the compound assignment operators all
 group right-to-left. All require a modifiable lvalue as their left
 A *braced-init-list* may appear on the right-hand side of
 - an assignment to a scalar, in which case the initializer list shall
   have at most a single element. The meaning of `x={v}`, where `T` is
+  the scalar type of the expression `x`, is that of `x=T{v}`. The
+ meaning of `x={}` is `x=T{}`.
+- an assignment to an object of class type, in which case the
+  initializer list is passed as the argument to the assignment operator
+ function selected by overload resolution ([[over.ass]],
+ [[over.match]]).
 ``` cpp
 complex<double> z;
 z = { 1,2 };              // meaning z.operator=({1,2\)}
 z += { 1, 2 };            // meaning z.operator+=({1,2\)}
     expression ',' assignment-expression
 ```
 A pair of expressions separated by a comma is evaluated left-to-right;
 the left expression is a discarded-value expression (Clause
+[[expr]]).[^27] Every value computation and side effect associated with
 the left expression is sequenced before every value computation and side
 effect associated with the right expression. The type and value of the
 result are the type and value of the right operand; the result is of the
 same value category as its right operand, and is a bit-field if its
+right operand is a glvalue and a bit-field. If the value of the right
+operand is a temporary ([[class.temporary]]), the result is that
+temporary.
 In contexts where comma is given a special meaning, in lists of
 arguments to functions ([[expr.call]]) and lists of initializers (
 [[dcl.init]]) the comma operator as described in Clause  [[expr]] can
 appear only in parentheses.
 ``` bnf
 constant-expression:
     conditional-expression
 ```
+A *conditional-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 expressions:
+- `this` ([[expr.prim.general]]), except in a `constexpr` function or a
+ `constexpr` constructor that is being evaluated as part of `e`;
 - an invocation of a function other than a `constexpr` constructor for a
+  literal class, a `constexpr` function, or an implicit invocation of a
+  trivial destructor ([[class.dtor]]) Overload resolution (
   [[over.match]]) is applied as usual ;
 - an invocation of an undefined `constexpr` function or an undefined
+  `constexpr` constructor;
+- an expression that would exceed the implementation-defined limits (see
   Annex  [[implimits]]);
+- an operation that would have undefined behavior including, for
+ example, signed integer overflow (Clause [[expr]]), certain pointer
+  arithmetic ([[expr.add]]), division by zero ([[expr.mul]]), or
+  certain shift operations ([[expr.shift]]) ;
 - a *lambda-expression* ([[expr.prim.lambda]]);
 - an lvalue-to-rvalue conversion ([[conv.lval]]) unless it is applied
   to
+  - a non-volatile glvalue of integral or enumeration type that refers
+ to a non-volatile const object with a preceding initialization,
+    initialized with a constant expression a string literal (
+    [[lex.string]]) corresponds to an array of such objects. , or
+  - a non-volatile glvalue that refers to a non-volatile object defined
+ with `constexpr`, or that refers to a non-mutable sub-object of such
+    an object, 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]]) or modification (
+ [[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]]) that is applied
+ to a glvalue that refers to a non-active member of a union or a
+  subobject thereof;
 - 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 initialized with a constant expression or
+  - it is a non-static data member of an object whose 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]]);
+- a conversion from type cv `void *` to a pointer-to-object type;
 - a dynamic cast ([[expr.dynamic.cast]]);
 - a `reinterpret_cast` ([[expr.reinterpret.cast]]);
 - a pseudo-destructor call ([[expr.pseudo]]);
+- 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 typeid expression ([[expr.typeid]]) whose operand is a glvalue of a
   polymorphic class type;
 - a *new-expression* ([[expr.new]]);
 - a *delete-expression* ([[expr.delete]]);
 - a relational ([[expr.rel]]) or equality ([[expr.eq]]) operator where
+  the result is unspecified; or
 - a *throw-expression* ([[except.throw]]).
+``` 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) {
+  return ++n;
+}
+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)
+```
+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. Such expressions may
+be used as array bounds ([[dcl.array]], [[expr.new]]), as bit-field
+lengths ([[class.bit]]), as enumerator initializers if the underlying
+type is not fixed ([[dcl.enum]]), and as alignments ([[dcl.align]]). A
+*converted constant expression* of type `T` is an expression, implicitly
+converted to a prvalue of type `T`, where the converted expression is a
+core constant expression and the implicit conversion sequence contains
+only user-defined conversions, lvalue-to-rvalue conversions (
+[[conv.lval]]), integral promotions ([[conv.prom]]), and integral
+conversions ([[conv.integral]]) other than narrowing conversions (
+[[dcl.init.list]]). 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 integral or enumeration non-type
+template arguments ([[temp.arg]]).
+A *constant expression* is either a glvalue core constant expression
+whose value refers to an object with static storage duration or to a
+function, or a prvalue core constant expression whose value is an object
+where, for that object and its subobjects:
+- each non-static data member of reference type refers to an object with
+  static storage duration or to a function, and
+- if the object or subobject 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 function, or a null
+  pointer value.
 Since this International Standard 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.[^28]
 ``` 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
 ```
 It is unspecified whether the value of `f()` will be `true` or `false`.
 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 (Clause  [[conv]]) to an integral or
+unscoped enumeration type and the selected conversion function shall be
 `constexpr`.
 ``` cpp
 struct A {
   constexpr A(int i) : val(i) { }
+  constexpr operator int() const { return val; }
+  constexpr operator long() const { return 43; }
 private:
   int val;
 };
 template<int> struct X { };
 constexpr A a = 42;
 [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.md#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
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [conv.qual]: conv.md#conv.qual
 [dcl.align]: dcl.md#dcl.align
 [dcl.array]: dcl.md#dcl.array
 [dcl.dcl]: dcl.md#dcl.dcl
 [dcl.enum]: dcl.md#dcl.enum
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.def]: dcl.md#dcl.fct.def
 [dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
+[dcl.fct.def.general]: dcl.md#dcl.fct.def.general
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.aggr]: dcl.md#dcl.init.aggr
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.init.ref]: dcl.md#dcl.init.ref
 [new.delete.single]: language.md#new.delete.single
 [over]: over.md#over
 [over.ass]: over.md#over.ass
 [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.oper]: over.md#over.match.oper
 [over.oper]: over.md#over.oper
 [over.over]: over.md#over.over
 [replacement.functions]: library.md#replacement.functions
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: language.md#support.runtime
 [support.types]: language.md#support.types
 [temp.arg]: temp.md#temp.arg
+[temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
 [temp.res]: temp.md#temp.res
 [temp.variadic]: temp.md#temp.variadic
 [type.info]: language.md#type.info
     `(*this)` ([[class.mfct.non-static]]).
 [^5]: This is true even if the subscript operator is used in the
     following common idiom: `&x[0]`.
+[^6]: If the class member access expression is evaluated, the
     subexpression evaluation happens even if the result is unnecessary
     to determine the value of the entire postfix expression, for example
     if the *id-expression* denotes a static member.
+[^7]: Note that `(*(E1))` is an lvalue.
+[^8]: The most derived object ([[intro.object]]) pointed or referred to
     by `v` can contain other `B` objects as base classes, but these are
     ignored.
+[^9]: The recommended name for such a class is `extended_type_info`.
+[^10]: If `p` is an expression of pointer type, then `*p`, `(*p)`,
     `*(p)`, `((*p))`, `*((p))`, and so on all meet this requirement.
+[^11]: Function types (including those used in pointer to member
     function types) are never cv-qualified; see  [[dcl.fct]].
+[^12]: The types may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^13]: `T1` and `T2` may have different cv-qualifiers, subject to the
     overall restriction that a `reinterpret_cast` cannot cast away
     constness.
+[^14]: This is sometimes referred to as a *type pun*.
+[^15]: `const_cast`
     is not limited to conversions that cast away a const-qualifier.
+[^16]: `sizeof(bool)` is not required to be `1`.
+[^17]: The actual size of a base class subobject may be less than the
     result of applying `sizeof` to the subobject, due to virtual base
     classes and less strict padding requirements on base class
     subobjects.
+[^18]: 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.
 [^19]: This may include evaluating a *new-initializer* and/or calling a
     constructor.
 [^20]: A lambda expression with a *lambda-introducer* that consists of
     empty square brackets can follow the `delete` keyword if the lambda
 [^22]: For non-zero-length arrays, this is the same as a pointer to the
     first element of the array created by that *new-expression*.
     Zero-length arrays do not have a first element.
+[^23]: If the static type of the object to be deleted is complete and is
+    different from the dynamic type, and the destructor is not virtual,
+    the size might be incorrect, but that case is already undefined, as
+    stated above.
+[^24]: This includes implicit calls such as the call to an allocation
     function in a *new-expression*.
+[^25]: This is often called truncation towards zero.
+[^26]: Another way to approach pointer arithmetic is first to convert
     the pointer(s) to character pointer(s): In this scheme the integral
     value of the expression added to or subtracted from the converted
     pointer is first multiplied by the size of the object originally
     pointed to, and the resulting pointer is converted back to the
     original type. For pointer subtraction, the result of the difference
     When viewed in this way, an implementation need only provide one
     extra byte (which might overlap another object in the program) just
     after the end of the object in order to satisfy the “one past the
     last element” requirements.
+[^27]: However, an invocation of an overloaded comma operator is an
     ordinary function call; hence, the evaluations of its argument
     expressions are unsequenced relative to one another (see
     [[intro.execution]]).
+[^28]: Nonetheless, implementations are encouraged to provide consistent
+    results, irrespective of whether the evaluation was performed during
+    translation and/or during program execution.

Diff to HTML by rtfpessoa