CWG2631 Immediate function evaluations in default arguments

In [intro.execution], cross-reference term for "unevaluated operand":
We have started attaching labels to defined terms, so we can directly
refer to the terms instead of just the containing subclause.

Fixes NB FR 005 (C++23 CD).

Author: burblebee

source/basic.tex

@@ -5585,6 +5585,10 @@
 \item
 The constituent expression of an expression is that expression.
 \item
+The constituent expression of a conversion is
+the corresponding implicit function call, if any, or
+the converted expression otherwise.
+\item
 The constituent expressions of a \grammarterm{braced-init-list} or
 of a (possibly parenthesized) \grammarterm{expression-list}
 are the constituent expressions of the elements of the respective list.
@@ -5632,6 +5636,15 @@
 Expressions appearing in the \grammarterm{compound-statement} of a \grammarterm{lambda-expression}
 are not subexpressions of the \grammarterm{lambda-expression}.
 \end{note}
+The \defnadjx{potentially-evaluated}{subexpressions}{subexpression} of
+an expression, conversion, or \grammarterm{initializer} $E$ are
+\begin{itemize}
+\item
+the constituent expressions of $E$ and
+\item
+the subexpressions thereof that
+are not subexpressions of a nested unevaluated operand\iref{term.unevaluated.operand}.
+\end{itemize}
 
 \pnum
 A \defn{full-expression} is

source/classes.tex

@@ -659,6 +659,11 @@
 shall not directly or indirectly cause the implicit definition of a
 defaulted default constructor for the enclosing class or the
 exception specification of that constructor.
+An immediate invocation\iref{expr.const} that
+is a potentially-evaluated subexpression\iref{intro.execution}
+of a default member initializer
+is neither evaluated nor checked for whether it
+is a constant expression at the point where the subexpression appears.
 
 \pnum
 A member shall not be declared with the \keyword{extern}

source/declarations.tex

@@ -4004,7 +4004,12 @@
 copy-initialization semantics\iref{dcl.init}.
 The names in the
 default argument are looked up, and the semantic constraints are checked,
-at the point where the default argument appears.
+at the point where the default argument appears, except that
+an immediate invocation\iref{expr.const} that
+is a potentially-evaluated subexpression\iref{intro.execution} of
+the \grammarterm{initializer-clause} in a \grammarterm{parameter-declaration} is
+neither evaluated
+nor checked for whether it is a constant expression at that point.
 Name lookup and checking of semantic constraints for default
 arguments of templated functions are performed as described in~\ref{temp.inst}.
 \begin{example}
@@ -4684,6 +4689,14 @@
 \end{note}
 \end{itemize}
 
+\pnum
+An immediate invocation\iref{expr.const} that is not evaluated where
+it appears\iref{dcl.fct.default,class.mem.general}
+is evaluated and checked for whether it is
+a constant expression at the point where
+the enclosing \grammarterm{initializer} is used in
+a function call, a constructor definition, or an aggregate initialization.
+
 \pnum
 An \grammarterm{initializer-clause} followed by an ellipsis is a
 pack expansion\iref{temp.variadic}.

source/expressions.tex

@@ -7923,8 +7923,7 @@
 or
 
 \item
-a subexpression of one of the above
-that is not a subexpression of a nested unevaluated operand\iref{term.unevaluated.operand}.
+a potentially-evaluated subexpression\iref{intro.execution} of one of the above.
 \end{itemize}
 
 \indextext{function!needed for constant evaluation}%

source/templates.tex

@@ -5978,13 +5978,17 @@
 It is unspecified whether or not an implementation implicitly instantiates a
 virtual member function of a class template if the virtual member function would
 not otherwise be instantiated.
-The use of a template specialization in a default argument
-shall not cause the template to be implicitly instantiated except that a
-class template may be instantiated where its complete type is needed to determine
-the correctness of the default argument.
+The use of a template specialization in
+a default argument or default member initializer
+shall not cause the template to be implicitly instantiated except
+where needed to determine
+the correctness of the default argument or default member initializer.
 The use of a default argument in a
 function call causes specializations in the default argument to be implicitly
 instantiated.
+Similarly, the use of a default member initializer
+in a constructor definition or an aggregate initialization
+causes specializations in the default member initializer to be instantiated.
 
 \pnum
 If a function template