[expr] Add subclauses and adjust cross-references to [expr].

Also move [basic.lval] into [expr].

Author: jensmaurer

source/basic.tex

@@ -270,7 +270,7 @@
 
 \pnum
 An expression is \defn{potentially evaluated} unless it is an
-unevaluated operand\iref{expr} or a subexpression thereof.
+unevaluated operand\iref{expr.prop} or a subexpression thereof.
 The set of \defn{potential results} of an expression \tcode{e} is
 defined as follows:
 \begin{itemize}
@@ -320,7 +320,7 @@
 and, if \tcode{x} is an object, \tcode{ex} is an element of
 the set of potential results of an expression \tcode{e}, where either the lvalue-to-rvalue
 conversion\iref{conv.lval} is applied to \tcode{e}, or \tcode{e} is
-a discarded-value expression\iref{expr}.
+a discarded-value expression\iref{expr.prop}.
 \tcode{this} is odr-used if it appears as a potentially-evaluated expression
 (including as the result of the implicit transformation in the body of a non-static
 member function~(\ref{class.mfct.non-static})).
@@ -2529,7 +2529,7 @@
 generates information associated with each such object that makes it
 possible to determine that object's type during program execution. For
 other objects, the interpretation of the values found therein is
-determined by the type of the \grammarterm{expression}{s}\iref{expr}
+determined by the type of the \grammarterm{expression}{s}\iref{expr.compound}
 used to access them.
 
 \pnum
@@ -4155,138 +4155,6 @@
 \end{example}%
 \indextext{type|)}
 
-\rSec1[basic.lval]{Lvalues and rvalues}
-\pnum
-Expressions are categorized according to the taxonomy in Figure~\ref{fig:categories}.
-
-\begin{importgraphic}
-{Expression category taxonomy}
-{fig:categories}
-{valuecategories.pdf}
-\end{importgraphic}
-
-\begin{itemize}
-\item A \defn{glvalue} is an expression whose evaluation determines the identity of an object, bit-field, or function.
-\item A \defn{prvalue} is an expression whose evaluation initializes an object or a bit-field,
-or computes the value of the operand of an operator,
-as specified by the context in which it appears.
-\item An \defn{xvalue} is a glvalue that denotes an object or bit-field whose resources can be reused (usually because it is near the end of its lifetime).
-\begin{example}
-Certain kinds of expressions involving rvalue references\iref{dcl.ref} yield xvalues,
-such as a call to a function whose return type is an rvalue reference
-or a cast to an rvalue reference type.
-\end{example}
-\item An \defn{lvalue} is a glvalue that is not an xvalue.
-\item An \defn{rvalue} is a prvalue or an xvalue.
-\end{itemize}
-\begin{note}
-Historically, lvalues and rvalues were so-called
-because they could appear on the left- and right-hand side of an assignment
-(although this is no longer generally true);
-glvalues are ``generalized'' lvalues,
-prvalues are ``pure'' rvalues,
-and xvalues are ``eXpiring'' lvalues.
-Despite their names, these terms classify expressions, not values.
-\end{note}
-Every expression belongs to exactly one of the fundamental classifications in this
-taxonomy: lvalue, xvalue, or prvalue. This property of an expression is called
-its \defn{value category}. \begin{note} The discussion of each built-in operator in
-\ref{expr} indicates the category of the value it yields and the value categories
-of the operands it expects. For example, the built-in assignment operators expect that
-the left operand is an lvalue and that the right operand is a prvalue and yield an
-lvalue as the result. User-defined operators are functions, and the categories of
-values they expect and yield are determined by their parameter and return types. \end{note}
-
-\pnum
-The \defnx{result}{result!prvalue} of a prvalue
-is the value that the expression stores into its context.
-A prvalue whose result is the value \placeholder{V}
-is sometimes said to have or name the value \placeholder{V}.
-The \defn{result object} of a prvalue
-is the object initialized by the prvalue;
-a prvalue
-that is used to compute the value of an operand of an operator or
-that has type \cv{}~\tcode{void}
-has no result object.
-\begin{note}
-Except when the prvalue is the operand of a \grammarterm{decltype-specifier},
-a prvalue of class or array type always has a result object.
-For a discarded prvalue, a temporary object is materialized; see \ref{expr}.
-\end{note}
-The \defnx{result}{result!glvalue} of a glvalue is the entity denoted by the expression.
-
-\pnum
-\begin{note}
-Whenever a glvalue appears in a context where a prvalue is expected, the glvalue is converted
-to a prvalue; see~\ref{conv.lval}, \ref{conv.array},
-and~\ref{conv.func}.
-An attempt to bind an rvalue reference to an lvalue is not such a context; see~\ref{dcl.init.ref}.
-\end{note}
-\begin{note}
-There are no prvalue bit-fields; if a bit-field is converted to a
-prvalue\iref{conv.lval}, a prvalue of the type of the bit-field is
-created, which might then be promoted\iref{conv.prom}.
-\end{note}
-
-\pnum
-\begin{note}
-Whenever a prvalue appears in a context where a glvalue is expected,
-the prvalue is converted to an xvalue; see~\ref{conv.rval}.
-\end{note}
-
-\pnum
-The discussion of reference initialization in~\ref{dcl.init.ref} and of
-temporaries in~\ref{class.temporary} indicates the behavior of lvalues
-and rvalues in other significant contexts.
-
-\pnum
-Unless otherwise indicated\iref{expr.call},
-a prvalue shall always have complete type or the \tcode{void} type.
-A glvalue shall not have type \cv{}~\tcode{void}.
-\begin{note}
-A glvalue may have complete or incomplete non-\tcode{void} type.
-Class and array prvalues can have cv-qualified types; other prvalues
-always have cv-unqualified types. See \ref{expr}.
-\end{note}
-
-\pnum
-An lvalue is \defn{modifiable} unless its type is const-qualified
-or is a function type.
-\begin{note}
-A program that attempts
-to modify an object through a nonmodifiable lvalue expression or through an rvalue expression
-is ill-formed~(\ref{expr.ass}, \ref{expr.post.incr}, \ref{expr.pre.incr}).
-\end{note}
-
-\pnum
-If a program attempts to access the stored value of an object through a glvalue
-of other than one of the following types the behavior is
-undefined:\footnote{The intent of this list is to specify those circumstances in which an
-object may or may not be aliased.}
-\begin{itemize}
-\item the dynamic type of the object,
-
-\item a cv-qualified version of the dynamic type of the object,
-
-\item a type similar (as defined in~\ref{conv.qual}) to the dynamic type
-of the object,
-
-\item a type that is the signed or unsigned type corresponding to the
-dynamic type of the object,
-
-\item a type that is the signed or unsigned type corresponding to a
-cv-qualified version of the dynamic type of the object,
-
-\item an aggregate or union type that includes one of the aforementioned types among its
-elements or non-static data members (including, recursively, an element or non-static data member of a
-subaggregate or contained union),
-
-\item a type that is a (possibly cv-qualified) base class type of the dynamic type of
-the object,
-
-\item a \tcode{char}, \tcode{unsigned char}, or \tcode{std::byte} type.
-\end{itemize}
-
 \rSec1[basic.exec]{Program execution}
 
 \rSec2[intro.execution]{Sequential execution}
@@ -4326,7 +4194,7 @@
 The \defnx{immediate subexpressions}{immediate subexpression} of an expression \tcode{e} are
 \begin{itemize}
 \item
-the constituent expressions of \tcode{e}'s operands\iref{expr},
+the constituent expressions of \tcode{e}'s operands\iref{expr.prop},
 \item
 any function call that \tcode{e} implicitly invokes,
 \item
@@ -4356,7 +4224,7 @@
 A \defn{full-expression} is
 \begin{itemize}
 \item
-an unevaluated operand\iref{expr},
+an unevaluated operand\iref{expr.prop},
 \item
 a \grammarterm{constant-expression}\iref{expr.const},
 \item

source/conversions.tex

@@ -41,7 +41,7 @@
 
 \begin{itemize}
 \item When used as operands of operators. The operator's requirements
-for its operands dictate the destination type\iref{expr}.
+for its operands dictate the destination type\iref{expr.compound}.
 
 \item When used in the condition of an \tcode{if} statement or iteration
 statement~(\ref{stmt.select}, \ref{stmt.iter}). The destination type is
@@ -661,6 +661,6 @@
 \begin{note}
 The integer conversion rank is used in the definition of the integral
 promotions\iref{conv.prom} and the usual arithmetic
-conversions\iref{expr}.
+conversions\iref{expr.prop}.
 \end{note}%
 \indextext{conversion!standard|)}

source/declarations.tex

@@ -1384,7 +1384,7 @@
 \end{itemize}
 
 The operand of the \tcode{decltype} specifier is an unevaluated
-operand\iref{expr}.
+operand\iref{expr.prop}.
 
 \begin{example}
 \begin{codeblock}
@@ -4076,7 +4076,7 @@
 calls a function previously declared \tcode{nodiscard}, or
 whose return type is a possibly cv-qualified class or enumeration type
 marked \tcode{nodiscard}. Appearance of a nodiscard call as
-a potentially-evaluated discarded-value expression\iref{expr}
+a potentially-evaluated discarded-value expression\iref{expr.prop}
 is discouraged unless explicitly cast to \tcode{void}.
 Implementations should issue a warning in such cases.
 This is typically because discarding the return value

source/declarators.tex

@@ -2305,7 +2305,7 @@
 The type of the \grammarterm{id-expression}
 \tcode{e} is called \tcode{E}.
 \begin{note}
-\tcode{E} is never a reference type\iref{expr}.
+\tcode{E} is never a reference type\iref{expr.prop}.
 \end{note}
 
 \pnum
@@ -2686,7 +2686,7 @@
 \ref{expr.type.conv}, \ref{expr.static.cast}, \ref{expr.cast}) to an
 unsigned narrow character type
 or \tcode{std::byte} type\iref{cstddef.syn}, or
-\item a discarded-value expression\iref{expr},
+\item a discarded-value expression\iref{expr.prop},
 \end{itemize}
 then the result of the operation is an indeterminate value.