From 636009347ef025378ad98b2abde75c9b3d78da5e Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sun, 15 Dec 2019 17:46:44 +0100 Subject: [PATCH 1/3] [std] Use $E$ as expression placeholder. --- source/basic.tex | 58 +++++++++++------------ source/declarations.tex | 46 +++++++++--------- source/exceptions.tex | 16 +++---- source/expressions.tex | 100 ++++++++++++++++++++-------------------- 4 files changed, 110 insertions(+), 110 deletions(-) diff --git a/source/basic.tex b/source/basic.tex index e154c791fa..892df01e84 100644 --- a/source/basic.tex +++ b/source/basic.tex @@ -300,38 +300,38 @@ an unevaluated operand\iref{expr.prop}, a subexpression thereof, or a conversion in an initialization or conversion sequence in such a context. -The set of \defn{potential results} of an expression \tcode{e} is +The set of \defn{potential results} of an expression $E$ is defined as follows: \begin{itemize} -\item If \tcode{e} is an +\item If $E$ is an \grammarterm{id-expression}\iref{expr.prim.id}, the set -contains only \tcode{e}. -\item If \tcode{e} is a subscripting operation\iref{expr.sub} with +contains only $E$. +\item If $E$ is a subscripting operation\iref{expr.sub} with an array operand, the set contains the potential results of that operand. -\item If \tcode{e} is a class member access +\item If $E$ is a class member access expression\iref{expr.ref} of the form -\tcode{e1 . \opt{template} e2} +\tcode{$E_1$ . \opt{template} $E_2$} naming a non-static data member, -the set contains the potential results of \tcode{e1}. -\item If \tcode{e} is a class member access expression +the set contains the potential results of $E_1$. +\item If $E$ is a class member access expression naming a static data member, the set contains the \grammarterm{id-expression} designating the data member. -\item If \tcode{e} is a pointer-to-member +\item If $E$ is a pointer-to-member expression\iref{expr.mptr.oper} of the form -\tcode{e1 .* e2}, -the set contains the potential results of \tcode{e1}. -\item If \tcode{e} has the form \tcode{(e1)}, the set contains the -potential results of \tcode{e1}. -\item If \tcode{e} is a glvalue conditional +\tcode{$E_1$ .* $E_2$}, +the set contains the potential results of $E_1$. +\item If $E$ has the form \tcode{($E_1$)}, the set contains the +potential results of $E_1$. +\item If $E$ is a glvalue conditional expression\iref{expr.cond}, the set is the union of the sets of potential results of the second and third operands. -\item If \tcode{e} is a comma expression\iref{expr.comma}, the set +\item If $E$ is a comma expression\iref{expr.comma}, the set contains the potential results of the right operand. \item Otherwise, the set is empty. \end{itemize} \begin{note} This set is a (possibly-empty) set of \grammarterm{id-expression}{s}, -each of which is either \tcode{e} or a subexpression of \tcode{e}. +each of which is either $E$ or a subexpression of $E$. \begin{example} In the following example, the set of potential results of the initializer of \tcode{n} contains the first \tcode{S::x} subexpression, but not the second @@ -386,8 +386,8 @@ \pnum A variable \tcode{x} whose name appears as a -potentially-evaluated expression \tcode{e} -is \defnx{odr-used}{odr-use} by \tcode{e} unless +potentially-evaluated expression $E$ +is \defnx{odr-used}{odr-use} by $E$ unless \begin{itemize} \item \tcode{x} is a reference that is @@ -395,12 +395,12 @@ \item \tcode{x} is a variable of non-reference type that is usable in constant expressions and has no mutable subobjects, and - \tcode{e} is an element of the set of potential results of an expression + $E$ is an element of the set of potential results of an expression of non-volatile-qualified non-class type to which the lvalue-to-rvalue conversion\iref{conv.lval} is applied, or \item \tcode{x} is a variable of non-reference type, and - \tcode{e} is an element of the set of potential results + $E$ is an element of the set of potential results of a discarded-value expression\iref{expr.prop} to which the lvalue-to-rvalue conversion is not applied. \end{itemize} @@ -5278,30 +5278,30 @@ \end{example} \pnum -The \defnx{immediate subexpressions}{immediate subexpression} of an expression \tcode{e} are +The \defnx{immediate subexpressions}{immediate subexpression} of an expression $E$ are \begin{itemize} \item -the constituent expressions of \tcode{e}'s operands\iref{expr.prop}, +the constituent expressions of $E$'s operands\iref{expr.prop}, \item -any function call that \tcode{e} implicitly invokes, +any function call that $E$ implicitly invokes, \item -if \tcode{e} is a \grammarterm{lambda-expression}\iref{expr.prim.lambda}, +if $E$ is a \grammarterm{lambda-expression}\iref{expr.prim.lambda}, the initialization of the entities captured by copy and the constituent expressions of the \grammarterm{initializer} of the \grammarterm{init-capture}{s}, \item -if \tcode{e} is a function call\iref{expr.call} or implicitly invokes a function, +if $E$ is a function call\iref{expr.call} or implicitly invokes a function, the constituent expressions of each default argument\iref{dcl.fct.default} used in the call, or \item -if \tcode{e} creates an aggregate object\iref{dcl.init.aggr}, +if $E$ creates an aggregate object\iref{dcl.init.aggr}, the constituent expressions of each default member initializer\iref{class.mem} used in the initialization. \end{itemize} \pnum -A \defn{subexpression} of an expression \tcode{e} is -an immediate subexpression of \tcode{e} or -a subexpression of an immediate subexpression of \tcode{e}. +A \defn{subexpression} of an expression $E$ is +an immediate subexpression of $E$ or +a subexpression of an immediate subexpression of $E$. \begin{note} Expressions appearing in the \grammarterm{compound-statement} of a \grammarterm{lambda-expression} are not subexpressions of the \grammarterm{lambda-expression}. diff --git a/source/declarations.tex b/source/declarations.tex index a18245ff72..7e97531529 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -1554,35 +1554,35 @@ \pnum \indextext{type specifier!\idxcode{decltype}}% -For an expression \tcode{e}, the type denoted by \tcode{decltype(e)} is defined as follows: +For an expression $E$, the type denoted by \tcode{decltype($E$)} is defined as follows: \begin{itemize} -\item if \tcode{e} is an unparenthesized \grammarterm{id-expression} +\item if $E$ is an unparenthesized \grammarterm{id-expression} naming a structured binding\iref{dcl.struct.bind}, -\tcode{decltype(e)} is the referenced type as given in +\tcode{decltype($E$)} is the referenced type as given in the specification of the structured binding declaration; -\item otherwise, if \tcode{e} is an unparenthesized \grammarterm{id-expression} +\item otherwise, if $E$ is an unparenthesized \grammarterm{id-expression} naming a non-type \grammarterm{template-parameter}\iref{temp.param}, -\tcode{decltype(e)} is the type of the \grammarterm{template-parameter} +\tcode{decltype($E$)} is the type of the \grammarterm{template-parameter} after performing any necessary type deduction (\ref{dcl.spec.auto}, \ref{dcl.type.class.deduct}); -\item otherwise, if \tcode{e} is an unparenthesized \grammarterm{id-expression} or +\item otherwise, if $E$ is an unparenthesized \grammarterm{id-expression} or an unparenthesized class member access\iref{expr.ref}, \tcode{decltype(e)} is the -type of the entity named by \tcode{e}. If there is no such entity, or -if \tcode{e} names a set of overloaded functions, the program is +type of the entity named by $E$. If there is no such entity, or +if $E$ names a set of overloaded functions, the program is ill-formed; -\item otherwise, if \tcode{e} is -an xvalue, \tcode{decltype(e)} is \tcode{T\&\&}, where \tcode{T} is the type -of \tcode{e}; +\item otherwise, if $E$ is +an xvalue, \tcode{decltype($E$)} is \tcode{T\&\&}, where \tcode{T} is the type +of $E$; -\item otherwise, if \tcode{e} is an lvalue, \tcode{decltype(e)} -is \tcode{T\&}, where \tcode{T} is the type of \tcode{e}; +\item otherwise, if $E$ is an lvalue, \tcode{decltype($E$)} +is \tcode{T\&}, where \tcode{T} is the type of $E$; -\item otherwise, \tcode{decltype(e)} is the type of \tcode{e}. +\item otherwise, \tcode{decltype(e)} is the type of $E$. \end{itemize} The operand of the \tcode{decltype} specifier is an unevaluated @@ -1900,7 +1900,7 @@ \pnum A type \tcode{T} containing a placeholder type, -and a corresponding initializer \tcode{e}, +and a corresponding initializer $E$, are determined as follows: \begin{itemize} \item @@ -1908,24 +1908,24 @@ in a function declared with a return type that contains a placeholder type, \tcode{T} is the declared return type -and \tcode{e} is the operand of the \tcode{return} statement. +and $E$ is the operand of the \tcode{return} statement. If the \tcode{return} statement has no operand, -then \tcode{e} is \tcode{void()}; +then $E$ is \tcode{void()}; \item for a variable declared with a type that contains a placeholder type, \tcode{T} is the declared type of the variable -and \tcode{e} is the initializer. +and $E$ is the initializer. If the initialization is direct-list-initialization, the initializer shall be a \grammarterm{braced-init-list} containing only a single \grammarterm{assignment-expression} -and \tcode{e} is the \grammarterm{assignment-expression}; +and $E$ is the \grammarterm{assignment-expression}; \item for a non-type template parameter declared with a type that contains a placeholder type, \tcode{T} is the declared type of the non-type template parameter -and \tcode{e} is the corresponding template argument. +and $E$ is the corresponding template argument. \end{itemize} In the case of a \tcode{return} statement with no operand @@ -1936,7 +1936,7 @@ \pnum If the deduction is for a \tcode{return} statement -and \tcode{e} is a \grammarterm{braced-init-list}\iref{dcl.init.list}, +and $E$ is a \grammarterm{braced-init-list}\iref{dcl.init.list}, the program is ill-formed. \pnum @@ -1954,7 +1954,7 @@ of template argument deduction from a function call\iref{temp.deduct.call}, where \tcode{P} is a function template parameter type and -the corresponding argument is \tcode{e}. +the corresponding argument is $E$. If the deduction fails, the declaration is ill-formed. Otherwise, $\mathtt{T}'$ is obtained by substituting the deduced \tcode{U} into \tcode{P}. @@ -1985,7 +1985,7 @@ \tcode{T} shall be the placeholder alone. The type deduced for \tcode{T} is determined as described in~\ref{dcl.type.simple}, as though -\tcode{e} had +$E$ had been the operand of the \tcode{decltype}. \begin{example} \begin{codeblock} diff --git a/source/exceptions.tex b/source/exceptions.tex index 45673e2c6a..82bc85da89 100644 --- a/source/exceptions.tex +++ b/source/exceptions.tex @@ -817,40 +817,40 @@ \end{example} \pnum -An expression \tcode{e} is +An expression $E$ is \defnx{potentially-throwing}{potentially-throwing!expression} if \begin{itemize} \item -\tcode{e} is a function call\iref{expr.call} +$E$ is a function call\iref{expr.call} whose \grammarterm{postfix-expression} has a function type, or a pointer-to-function type, with a potentially-throwing exception specification, or \item -\tcode{e} implicitly invokes a function +$E$ implicitly invokes a function (such as an overloaded operator, an allocation function in a \grammarterm{new-expression}, a constructor for a function argument, -or a destructor if \tcode{e} is a full-expression\iref{intro.execution}) +or a destructor if $E$ is a full-expression\iref{intro.execution}) that is potentially-throwing, or \item -\tcode{e} is a \grammarterm{throw-expression}\iref{expr.throw}, +$E$ is a \grammarterm{throw-expression}\iref{expr.throw}, or \item -\tcode{e} is a \tcode{dynamic_cast} expression that casts to a reference type and +$E$ is a \tcode{dynamic_cast} expression that casts to a reference type and requires a runtime check\iref{expr.dynamic.cast}, or \item -\tcode{e} is a \tcode{typeid} expression applied to a +$E$ is a \tcode{typeid} expression applied to a (possibly parenthesized) built-in unary \tcode{*} operator applied to a pointer to a polymorphic class type\iref{expr.typeid}, or \item any of the immediate subexpressions\iref{intro.execution} -of \tcode{e} is potentially-throwing. +of $E$ is potentially-throwing. \end{itemize} \pnum diff --git a/source/expressions.tex b/source/expressions.tex index bb3891859d..cc8fcb9e7a 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -526,28 +526,28 @@ \end{note} \pnum -An expression \tcode{e} can be +An expression $E$ can be \defnx{implicitly converted}{conversion!implicit} to a type \tcode{T} if and only if the -declaration \tcode{T t=e;} is well-formed, for some invented temporary +declaration \tcode{T t=$E$;} is well-formed, for some invented temporary variable \tcode{t}\iref{dcl.init}. \pnum Certain language constructs require that an expression be converted to a Boolean -value. An expression \tcode{e} appearing in such a context is said to be +value. An expression $E$ appearing in such a context is said to be \defnx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}} and is well-formed if and only if -the declaration \tcode{bool t(e);} is well-formed, for some invented temporary +the declaration \tcode{bool t($E$);} is well-formed, for some invented temporary variable \tcode{t}\iref{dcl.init}. \pnum Certain language constructs require conversion to a value having one of a specified set of types appropriate to the construct. An -expression \tcode{e} of class type \tcode{E} appearing in such a +expression $E$ of class type \tcode{C} appearing in such a context is said to be \indextext{conversion!contextual}% \defn{contextually implicitly converted} to a specified type \tcode{T} and is -well-formed if and only if \tcode{e} can be implicitly converted to a type \tcode{T} +well-formed if and only if $E$ can be implicitly converted to a type \tcode{T} that is determined as follows: -\tcode{E} is searched for non-explicit conversion functions +\tcode{C} is searched for non-explicit conversion functions whose return type is \cv{} \tcode{T} or reference to \cv{} \tcode{T} such that \tcode{T} is allowed by the context. There shall be exactly one such \tcode{T}. @@ -559,7 +559,7 @@ The result is an lvalue if \tcode{T} is an lvalue reference type or an rvalue reference to function type\iref{dcl.ref}, an xvalue if \tcode{T} is an rvalue reference to object type, -and a prvalue otherwise. The expression \tcode{e} +and a prvalue otherwise. The expression $E$ is used as a glvalue if and only if the initialization uses it as a glvalue. \pnum @@ -600,13 +600,13 @@ \pnum When an lvalue-to-rvalue conversion -is applied to an expression \tcode{e}, and either +is applied to an expression $E$, and either \begin{itemize} -\item \tcode{e} is not potentially evaluated, or -\item the evaluation of \tcode{e} results in the evaluation of a member - \tcode{ex} of the set of potential results of \tcode{e}, and \tcode{ex} +\item $E$ is not potentially evaluated, or +\item the evaluation of $E$ results in the evaluation of a member + $E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$ names a variable \tcode{x} that is not odr-used by - \tcode{ex}\iref{basic.def.odr}, + $E_\tcode{x}$\iref{basic.def.odr}, \end{itemize} the value contained in the referenced object is not accessed. \begin{example} @@ -1228,10 +1228,10 @@ \pnum \indextext{expression!parenthesized}% -A parenthesized expression \tcode{(E)} -is a primary expression whose type, value, and value category are identical to those of \tcode{E}. +A parenthesized expression \tcode{($E$)} +is a primary expression whose type, value, and value category are identical to those of $E$. The parenthesized expression can be used in exactly the same contexts as -those where \tcode{E} can be used, and with the same +those where $E$ can be used, and with the same meaning, except as otherwise indicated. \rSec2[expr.prim.id]{Names} @@ -2663,7 +2663,7 @@ \pnum A \grammarterm{compound-requirement} asserts properties -of the \grammarterm{expression} \tcode{E}. Substitution +of the \grammarterm{expression} $E$. Substitution of template arguments (if any) and verification of semantic properties proceed in the following order: @@ -2674,7 +2674,7 @@ \item If the \tcode{noexcept} specifier is present, -\tcode{E} shall not be a potentially-throwing expression\iref{except.spec}. +$E$ shall not be a potentially-throwing expression\iref{except.spec}. \item If the \grammarterm{return-type-requirement} is present, then: @@ -3648,24 +3648,24 @@ a program that necessitates such a cast is ill-formed. \pnum -An expression \tcode{e} can be explicitly converted to a type \tcode{T} +An expression $E$ can be explicitly converted to a type \tcode{T} if there is an implicit conversion sequence\iref{over.best.ics} -from \tcode{e} to \tcode{T}, +from $E$ to \tcode{T}, if overload resolution for a direct-initialization\iref{dcl.init} -of an object or reference of type \tcode{T} from \tcode{e} +of an object or reference of type \tcode{T} from $E$ would find at least one viable function\iref{over.match.viable}, or if \tcode{T} is an aggregate type\iref{dcl.init.aggr} having a first element \tcode{x} and there is an implicit conversion sequence -from \tcode{e} to the type of \tcode{x}. +from $E$ to the type of \tcode{x}. If \tcode{T} is a reference type, the effect is the same as performing the declaration and initialization \begin{codeblock} -T t(e); +T t(@$E$@); \end{codeblock} for some invented temporary variable \tcode{t}\iref{dcl.init} and then using the temporary variable as the result of the conversion. -Otherwise, the result object is direct-initialized from \tcode{e}. +Otherwise, the result object is direct-initialized from $E$. \begin{note} The conversion is ill-formed when attempting to convert an expression of class type to an inaccessible or ambiguous base class. @@ -6863,14 +6863,14 @@ \end{itemize} \pnum -An expression \tcode{e} is a \defnadj{core constant}{expression} -unless the evaluation of \tcode{e}, following the rules of the abstract +An expression $E$ is a \defnadj{core constant}{expression} +unless the evaluation of $E$, following the rules of the abstract machine\iref{intro.execution}, would evaluate one of the following: \begin{itemize} \item \tcode{this}\iref{expr.prim.this}, except in a constexpr function\iref{dcl.constexpr} that is being evaluated as part -of \tcode{e}; +of $E$; \item an invocation of a non-constexpr function @@ -6893,7 +6893,7 @@ for an object unless \begin{itemize} \item the object is usable in constant expressions or - \item its lifetime began within the evaluation of \tcode{e}; + \item its lifetime began within the evaluation of $E$; \end{itemize} \item @@ -6922,7 +6922,7 @@ \item a non-volatile glvalue of literal type that refers to a non-volatile object - whose lifetime began within the evaluation of \tcode{e}; + whose lifetime began within the evaluation of $E$; \end{itemize} \item @@ -6938,7 +6938,7 @@ an invocation of an implicitly-defined copy/move constructor or copy/move assignment operator for a union whose active member (if any) is mutable, -unless the lifetime of the union object began within the evaluation of \tcode{e}; +unless the lifetime of the union object began within the evaluation of $E$; \item an \grammarterm{id-expression} that refers to a variable or @@ -6949,7 +6949,7 @@ it is usable in constant expressions or \item - its lifetime began within the evaluation of \tcode{e}; + its lifetime began within the evaluation of $E$; \end{itemize} \item @@ -7000,30 +7000,30 @@ \ref{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 \tcode{e}; +whose lifetime began within the evaluation of $E$; \item a \grammarterm{new-expression}\iref{expr.new}, unless the selected allocation function is a replaceable global allocation function~(\ref{new.delete.single}, \ref{new.delete.array}) and -the allocated storage is deallocated within the evaluation of \tcode{e}; +the allocated storage is deallocated within the evaluation of $E$; \item a \grammarterm{delete-expression}\iref{expr.delete}, unless it deallocates a region of storage -allocated within the evaluation of \tcode{e}; +allocated within the evaluation of $E$; \item a call to an instance of \tcode{std::allocator::allocate}\iref{allocator.members}, -unless the allocated storage is deallocated within the evaluation of \tcode{e}; +unless the allocated storage is deallocated within the evaluation of $E$; \item a call to an instance of \tcode{std::allocator::deallocate}\iref{allocator.members}, unless it deallocates a region of storage -allocated within the evaluation of \tcode{e}; +allocated within the evaluation of $E$; \item an \grammarterm{await-expression}\iref{expr.await}; @@ -7048,11 +7048,11 @@ an invocation of the \tcode{va_arg} macro\iref{cstdarg.syn}. \end{itemize} -If \tcode{e} satisfies the constraints of a core constant expression, but -evaluation of \tcode{e} would evaluate an operation that has undefined behavior +If $E$ satisfies the constraints of a core constant expression, but +evaluation of $E$ would evaluate an operation that has undefined behavior as specified in \ref{library} through \ref{\lastlibchapter} of this document, or an invocation of the \tcode{va_start} macro\iref{cstdarg.syn}, -it is unspecified whether \tcode{e} is a core constant expression. +it is unspecified whether $E$ is a core constant expression. \begin{example} \begin{codeblock} @@ -7096,10 +7096,10 @@ \pnum For the purposes of determining -whether an expression \tcode{e} is a core constant expression, +whether an expression $E$ is a core constant expression, the evaluation of a call to a member function of \tcode{std::allocator} as defined in \ref{allocator.members}, where \tcode{T} is a literal type, -does not disqualify \tcode{e} from being a core constant expression, +does not disqualify $E$ from being a core constant expression, even if the actual evaluation of such a call would otherwise fail the requirements for a core constant expression. Similarly, the evaluation of a call to @@ -7107,7 +7107,7 @@ \tcode{std::ranges::destroy_at}, \tcode{std::construct_at}, or \tcode{std::ranges::construct_at} -does not disqualify \tcode{e} +does not disqualify $E$ from being a core constant expression unless: \begin{itemize} \item @@ -7115,17 +7115,17 @@ the first argument, of type \tcode{T*}, does not point to storage allocated with \tcode{std::allocator} or - to an object whose lifetime began within the evaluation of \tcode{e}, or + to an object whose lifetime began within the evaluation of $E$, or the evaluation of the underlying constructor call - disqualifies \tcode{e} from being a core constant expression, or + disqualifies $E$ from being a core constant expression, or \item for a call to \tcode{std::destroy_at} or \tcode{std::ranges::destroy_at}, the first argument, of type \tcode{T*}, does not point to storage allocated with \tcode{std::allocator} or - to an object whose lifetime began within the evaluation of \tcode{e}, or + to an object whose lifetime began within the evaluation of $E$, or the evaluation of the underlying destructor call - disqualifies \tcode{e} from being a core constant expression. + disqualifies $E$ from being a core constant expression. \end{itemize} \pnum @@ -7136,11 +7136,11 @@ \item it is of class type or (possibly multi-dimensional) array thereof, that class type has a constexpr destructor, and - for a hypothetical expression \tcode{e} + for a hypothetical expression $E$ whose only effect is to destroy \tcode{a}, - \tcode{e} would be a core constant expression + $E$ would be a core constant expression if the lifetime of \tcode{a} and its non-mutable subobjects - (but not its mutable subobjects) were considered to start within \tcode{e}. + (but not its mutable subobjects) were considered to start within $E$. \end{itemize} \pnum @@ -7284,7 +7284,7 @@ An immediate invocation shall be a constant expression. \pnum -An expression or conversion \tcode{e} is \defn{manifestly constant-evaluated} +An expression or conversion $E$ is \defn{manifestly constant-evaluated} if it is: \begin{itemize} \item a \grammarterm{constant-expression}, or From f3a5f7abe494f34c15e3b8d8ba927bd69da42210 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Wed, 4 Mar 2020 14:10:02 -0800 Subject: [PATCH 2/3] fixup a couple of missed places --- source/declarations.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/declarations.tex b/source/declarations.tex index 7e97531529..8ff0fbaf21 100644 --- a/source/declarations.tex +++ b/source/declarations.tex @@ -1570,7 +1570,7 @@ \item otherwise, if $E$ is an unparenthesized \grammarterm{id-expression} or an unparenthesized class -member access\iref{expr.ref}, \tcode{decltype(e)} is the +member access\iref{expr.ref}, \tcode{decltype($E$)} is the type of the entity named by $E$. If there is no such entity, or if $E$ names a set of overloaded functions, the program is ill-formed; @@ -1582,7 +1582,7 @@ \item otherwise, if $E$ is an lvalue, \tcode{decltype($E$)} is \tcode{T\&}, where \tcode{T} is the type of $E$; -\item otherwise, \tcode{decltype(e)} is the type of $E$. +\item otherwise, \tcode{decltype($E$)} is the type of $E$. \end{itemize} The operand of the \tcode{decltype} specifier is an unevaluated From ed60a13f49118d926f4c67e29d96e5c8dc7a7854 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Wed, 4 Mar 2020 14:15:44 -0800 Subject: [PATCH 3/3] fixup remove unreferenced variable from definition of manifestly constant-evaluated --- source/expressions.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/expressions.tex b/source/expressions.tex index cc8fcb9e7a..3c51ae6ee9 100644 --- a/source/expressions.tex +++ b/source/expressions.tex @@ -7284,7 +7284,7 @@ An immediate invocation shall be a constant expression. \pnum -An expression or conversion $E$ is \defn{manifestly constant-evaluated} +An expression or conversion is \defn{manifestly constant-evaluated} if it is: \begin{itemize} \item a \grammarterm{constant-expression}, or