[std] Fix cross-references to 'unevaluated operand'

Author: jensmaurer

source/algorithms.tex

@@ -10805,7 +10805,7 @@
 \pnum
 \constraints
 The expression \tcode{::new (declval<void*>()) T(declval<Args>()...)}
-is well-formed when treated as an unevaluated operand.
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \effects

source/declarations.tex

@@ -1589,7 +1589,7 @@
 \end{itemize}
 
 The operand of the \keyword{decltype} specifier is an unevaluated
-operand\iref{expr.prop}.
+operand\iref{term.unevaluated.operand}.
 
 \begin{example}
 \begin{codeblock}
@@ -4102,7 +4102,7 @@
 int f(int a, int b = a);            // error: parameter \tcode{a} used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter \tcode{I} found
-int h(int a, int b = sizeof(a));    // OK, unevaluated operand
+int h(int a, int b = sizeof(a));    // OK, unevaluated operand\iref{term.unevaluated.operand}
 \end{codeblock}
 \end{example}
 A non-static member shall not appear in a default argument unless it appears as

source/expressions.tex

@@ -424,6 +424,7 @@
 \rSec2[expr.context]{Context dependence}
 
 \pnum
+\label{term.unevaluated.operand}%
 In some contexts, \defnx{unevaluated operands}{unevaluated operand}
 appear~(\ref{expr.prim.req},
 \ref{expr.typeid},
@@ -1382,7 +1383,7 @@
 In the declaration of \tcode{p2},
 those constraints are required to be satisfied
 even though
-\tcode{f} is an unevaluated operand\iref{expr.prop}.
+\tcode{f} is an unevaluated operand\iref{term.unevaluated.operand}.
 \end{example}
 \end{note}
 
@@ -2622,7 +2623,7 @@
 A \grammarterm{requires-expression} is a prvalue of type \tcode{bool}
 whose value is described below.
 Expressions appearing within a \grammarterm{requirement-body}
-are unevaluated operands\iref{expr.prop}.
+are unevaluated operands\iref{term.unevaluated.operand}.
 
 \pnum
 \begin{example}
@@ -2709,7 +2710,7 @@
 \begin{note}
 The enclosing \grammarterm{requires-expression} will evaluate to \keyword{false}
 if substitution of template arguments into the \grammarterm{expression} fails.
-The \grammarterm{expression} is an unevaluated operand\iref{expr.prop}.
+The \grammarterm{expression} is an unevaluated operand\iref{term.unevaluated.operand}.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -2884,7 +2885,7 @@
 \end{example}
 
 \pnum
-A local parameter shall only appear as an unevaluated operand\iref{expr.prop}
+A local parameter shall only appear as an unevaluated operand\iref{term.unevaluated.operand}
 within the \grammarterm{constraint-expression}.
 \begin{example}
 \begin{codeblock}
@@ -3674,7 +3675,7 @@
 If the expression is a prvalue,
 the temporary materialization conversion\iref{conv.rval}
 is applied.
-The expression is an unevaluated operand\iref{expr.prop}.
+The expression is an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 When \keyword{typeid} is applied to a \grammarterm{type-id}, the result
@@ -4664,7 +4665,7 @@
 The \keyword{sizeof} operator yields the number of bytes
 occupied by a non-potentially-overlapping object of the type
 of its operand. The operand is either an expression,
-which is an unevaluated operand\iref{expr.prop}, or a parenthesized
+which is an unevaluated operand\iref{term.unevaluated.operand}, or a parenthesized
 \grammarterm{type-id}.
 \indextext{type!incomplete}%
 The \keyword{sizeof} operator shall not be applied to an expression that
@@ -4779,7 +4780,7 @@
 \indextext{\idxcode{noexcept}}%
 \indextext{expression!\idxcode{noexcept}}%
 The \keyword{noexcept} operator determines whether the evaluation of its operand,
-which is an unevaluated operand\iref{expr.prop}, can throw an
+which is an unevaluated operand\iref{term.unevaluated.operand}, can throw an
 exception\iref{except.throw}.
 
 \begin{bnf}
@@ -6903,7 +6904,7 @@
 A simple assignment whose left operand is of
 a volatile-qualified type is deprecated\iref{depr.volatile.type}
 unless the (possibly parenthesized) assignment is a discarded-value expression or
-an unevaluated operand.
+an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 The behavior of an expression of the form \tcode{E1 \placeholder{op}= E2}
@@ -7539,7 +7540,7 @@
 \end{itemize}
 \begin{note}
 A manifestly constant-evaluated expression
-is evaluated even in an unevaluated operand.
+is evaluated even in an unevaluated operand\iref{term.unevaluated.operand}.
 \end{note}
 
 \pnum
@@ -7569,7 +7570,7 @@
 
 \item
 a subexpression of one of the above
-that is not a subexpression of a nested unevaluated operand.
+that is not a subexpression of a nested unevaluated operand\iref{term.unevaluated.operand}.
 \end{itemize}
 
 \indextext{function!needed for constant evaluation}%

source/future.tex

@@ -1629,7 +1629,7 @@
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand,
+when treated as an unevaluated operand\iref{term.unevaluated.operand},
 then specializations of each of the two templates meet
 the \oldconcept{TransformationTrait} requirements with a base characteristic of
 \tcode{integral_constant<size_t, TS::value>}.

source/iostreams.tex

@@ -5673,7 +5673,7 @@
 \pnum
 \constraints
 The expression \tcode{is >> std::forward<T>(x)} is well-formed
-when treated as an unevaluated operand and
+when treated as an unevaluated operand\iref{term.unevaluated.operand} and
 \tcode{Istream} is publicly and unambiguously derived from \tcode{ios_base}.
 
 \pnum

source/threads.tex

@@ -7483,7 +7483,7 @@
 \pnum
 \constraints
 \tcode{\&F::operator()} is well-formed when
-treated as an unevaluated operand and
+treated as an unevaluated operand\iref{term.unevaluated.operand} and
 \tcode{decltype(\brk{}\&F::operator())} is of the form
 \tcode{R(G::*)(A...)}~\cv{}~\tcode{\opt{\&}~\opt{noexcept}}
 for a class type \tcode{G}.

source/time.tex

@@ -1182,7 +1182,7 @@
 are valid and each denotes a type\iref{temp.deduct},
 \item the expression
 \tcode{T::is_steady}
-is well-formed when treated as an unevaluated operand,
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand},
 \item the expression
 \tcode{T::now()}
 is well-formed when treated as an unevaluated operand.
@@ -10988,7 +10988,7 @@
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), fmt.c_str(), tp)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand.
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \returns
@@ -11013,7 +11013,7 @@
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), fmt.c_str(), tp, addressof(abbrev))
 \end{codeblock}
-is well-formed when treated as an unevaluated operand.
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \returns
@@ -11041,7 +11041,7 @@
             declval<basic_string<charT, traits, Alloc>*>(),
             &offset)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand.
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \returns
@@ -11073,7 +11073,7 @@
 from_stream(declval<basic_istream<charT, traits>&>(),
             fmt.c_str(), tp, addressof(abbrev), &offset)
 \end{codeblock}
-is well-formed when treated as an unevaluated operand.
+is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \returns

source/utilities.tex

@@ -407,7 +407,7 @@
 
 \pnum
 The library provides the function template \tcode{declval} to simplify the definition of
-expressions which occur as unevaluated operands\iref{expr.prop}.
+expressions which occur as unevaluated operands\iref{term.unevaluated.operand}.
 
 \indexlibraryglobal{declval}%
 \begin{itemdecl}
@@ -2108,7 +2108,7 @@
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand, then
+when treated as an unevaluated operand\iref{term.unevaluated.operand}, then
 each specialization of the template meets the \oldconcept{Unary\-Type\-Trait} requirements\iref{meta.rqmts}
 with a base characteristic of
 \begin{codeblock}
@@ -15591,7 +15591,7 @@
 and return type \tcode{R}
 if the expression
 \tcode{\placeholdernc{INVOKE}<R>(declval<F\&>(), declval<ArgTypes>()...)},
-considered as an unevaluated operand\iref{expr.prop}, is
+considered as an unevaluated operand\iref{term.unevaluated.operand}, is
 well-formed\iref{func.require}.
 
 \pnum
@@ -15747,7 +15747,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{\&F::operator()} is well-formed when treated as an unevaluated operand and
+\tcode{\&F::operator()} is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand} and
 \tcode{decltype(\brk{}\&F::operator())} is of the form
 \tcode{R(G::*)(A...)}~\cv{}~\tcode{\opt{\&}~\opt{noexcept}}
 for a class type \tcode{G}.
@@ -17181,7 +17181,7 @@
   \tcode{struct is_assignable;} &
   The expression \tcode{declval<T>() =} \tcode{declval<U>()} is well-formed
   when treated as an unevaluated
-  operand\iref{expr.prop}. Access checking is performed as if in a context
+  operand\iref{term.unevaluated.operand}. Access checking is performed as if in a context
   unrelated to \tcode{T} and \tcode{U}. Only the validity of the immediate context
   of the assignment expression is considered.
 \begin{tailnote}
@@ -17216,7 +17216,7 @@
   \tcode{struct is_swappable_with;} &
   The expressions \tcode{swap(declval<T>(), declval<U>())} and
   \tcode{swap(declval<U>(), declval<T>())} are each well-formed
-  when treated as an unevaluated operand\iref{expr.prop}
+  when treated as an unevaluated operand\iref{term.unevaluated.operand}
   in an overload-resolution context
   for swappable values\iref{swappable.requirements}.
   Access checking is performed as if in a context
@@ -17254,7 +17254,7 @@
   for which the expression
   \tcode{declval<U\&>().\~U()}
   is well-formed
-  when treated as an unevaluated operand\iref{expr.prop},
+  when treated as an unevaluated operand\iref{term.unevaluated.operand},
   where \tcode{U} is
   \tcode{remove_all_extents_t<T>}. &
   \tcode{T} shall be a complete type, \cv{}~\keyword{void},
@@ -17680,7 +17680,7 @@
 \tcode{template<class Fn, class... ArgTypes>}\br
  \tcode{struct is_invocable;}                      &
  The expression \tcode{\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...)}
- is well-formed when treated as an unevaluated operand                &
+ is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand} &
  \tcode{Fn} and all types in the template parameter pack \tcode{ArgTypes}
  shall be complete types, \cv{}~\keyword{void}, or
  arrays of unknown bound.                                             \\ \rowsep
@@ -18144,7 +18144,7 @@
  \tcode{struct invoke_result;}
  &
  If the expression \tcode{\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...)}
- is well-formed when treated as an unevaluated operand\iref{expr.prop},
+ is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand},
  the member typedef \tcode{type} names the type
  \tcode{decltype(\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...))};
  otherwise, there shall be no member \tcode{type}. Access checking is
@@ -21350,7 +21350,7 @@
 typename Context::template formatter_type<T>()
   .format(declval<const T&>(), declval<Context&>())
 \end{codeblock}
-shall be well-formed when treated as an unevaluated operand.
+shall be well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.
 
 \pnum
 \effects