P1073R3 Immediate functions

Author: jensmaurer

source/basic.tex

@@ -4803,6 +4803,8 @@
 \item
 a \grammarterm{constant-expression}\iref{expr.const},
 \item
+an immediate invocation\iref{expr.const},
+\item
 an \grammarterm{init-declarator}\iref{dcl.decl} or
 a \grammarterm{mem-initializer}\iref{class.base.init},
 including the constituent expressions of the initializer,

source/classes.tex

@@ -3712,7 +3712,11 @@
 \begin{note}
 Virtual functions support dynamic binding and object-oriented
 programming. \end{note} A class that declares or inherits a virtual function is
-called a \defnadj{polymorphic}{class}.
+called a \defnadj{polymorphic}{class}.\footnote{If
+all virtual functions are immediate functions,
+the class is still polymorphic even though
+its internal representation might not otherwise require
+any additions for that polymorphic behavior.}
 
 \pnum
 If a virtual member function \tcode{vf} is declared in a class
@@ -4044,6 +4048,12 @@
 function with a deleted definition.%
 \indextext{function!virtual|)}
 
+\pnum
+A \tcode{consteval} virtual function shall not override
+a virtual function that is not \tcode{consteval}.
+A \tcode{consteval} virtual function shall not be overridden by
+a virtual function that is not \tcode{consteval}.
+
 \pnum
 If an overriding function specifies contract conditions\iref{dcl.attr.contract},
 it shall specify the same list of contract conditions as

source/compatibility.tex

@@ -1796,8 +1796,11 @@
 to introduce constraints through a \grammarterm{requires-clause} or
 a \grammarterm{requires-expression}. The \tcode{concept} keyword is
 added to enable the definition of concepts\iref{temp.concept}.
+The \tcode{consteval} keyword is added to
+declare immediate functions\iref{dcl.constexpr}.
 \effect
-Valid ISO \CppXVII{} code using \tcode{concept} or \tcode{requires}
+Valid ISO \CppXVII{} code
+using \tcode{concept}, \tcode{consteval}, or \tcode{requires}
 as an identifier is not valid in this International Standard.
 
 \diffref{lex.operators}

source/declarations.tex

@@ -253,6 +253,7 @@
     \terminal{friend}\br
     \terminal{typedef}\br
     \terminal{constexpr}\br
+    \terminal{consteval}\br
     \terminal{inline}
 \end{bnf}
 
@@ -269,9 +270,11 @@
 same type.
 
 \pnum
-Each \grammarterm{decl-specifier} shall appear at most once in a complete
-\grammarterm{decl-specifier-seq}, except that
-\tcode{long} may appear twice.
+Each \grammarterm{decl-specifier}
+shall appear at most once in a complete \grammarterm{decl-specifier-seq},
+except that \tcode{long} may appear twice.
+The \tcode{constexpr} and \tcode{consteval} \grammarterm{decl-specifier}{s}
+shall not both appear in a \grammarterm{decl-specifier-seq}.
 
 \pnum
 \indextext{ambiguity!declaration type}%
@@ -733,17 +736,21 @@
 \indextext{specifier!\idxcode{constexpr}}
 
 \pnum
-The \tcode{constexpr} specifier shall be applied only to the definition of
-a variable or variable template or
-the declaration of a
-function or function template.
-A function or static data member declared with the \tcode{constexpr}
-specifier is implicitly an inline function or variable\iref{dcl.inline}.
+The \tcode{constexpr} specifier shall be applied only to
+the definition of a variable or variable template or
+the declaration of a function or function template.
+The \tcode{consteval} specifier shall be applied only to
+the declaration of a function or function template.
+A function or static data member
+declared with the \tcode{constexpr} or \tcode{consteval} specifier
+is implicitly an inline function or variable\iref{dcl.inline}.
 If any declaration of a function or function template has
-a \tcode{constexpr} specifier,
-then all its declarations shall contain the \tcode{constexpr} specifier. \begin{note} An
-explicit specialization can differ from the template declaration with respect to the
-\tcode{constexpr} specifier. \end{note}
+a \tcode{constexpr} or \tcode{consteval} specifier,
+then all its declarations shall contain the same specifier.
+\begin{note}
+An explicit specialization can differ from the template declaration
+with respect to the \tcode{constexpr} or \tcode{consteval} specifier.
+\end{note}
 \begin{note}
 Function parameters cannot be declared \tcode{constexpr}.\end{note}
 \begin{example}
@@ -773,12 +780,17 @@
 \end{example}
 
 \pnum
-A \tcode{constexpr} specifier used in the declaration of a function that is not a
-constructor declares that
-function to be a \defnx{constexpr function}{specifier!\idxcode{constexpr}!function}. Similarly, a
-\tcode{constexpr} specifier used in
-a constructor declaration declares that constructor to be a
-\defnx{constexpr constructor}{specifier!\idxcode{constexpr}!constructor}.
+A \tcode{constexpr} or \tcode{consteval} specifier
+used in the declaration of a function that is not a constructor
+declares that function to be
+a \defnx{constexpr function}{specifier!\idxcode{constexpr}!function}.
+Similarly, a \tcode{constexpr} or \tcode{consteval} specifier used in
+a constructor declaration declares that constructor to be
+a \defnx{constexpr constructor}{specifier!\idxcode{constexpr}!constructor}.
+A function or constructor declared with the \tcode{consteval} specifier
+is called an \defn{immediate function}.
+A destructor, an allocation function, or a deallocation function
+shall not be declared with the \tcode{consteval} specifier.
 
 \pnum
 \indextext{specifier!\idxcode{constexpr}!function}
@@ -948,8 +960,9 @@
 \end{itemize}
 
 \pnum
-The \tcode{constexpr} specifier has no
-effect on the type of a constexpr function or a constexpr constructor.  \begin{example}
+The \tcode{constexpr} and \tcode{consteval} specifier have no
+effect on the type of a constexpr function or a constexpr constructor.
+\begin{example}
 \begin{codeblock}
 constexpr int bar(int x, int y)         // OK
     { return x + y + x*y; }
@@ -1430,7 +1443,8 @@
 \end{note}
 
 \pnum
-If the operand of a \grammarterm{decltype-specifier} is a prvalue,
+If the operand of a \grammarterm{decltype-specifier} is a prvalue
+and is not a (possibly parenthesized) immediate invocation\iref{expr.const},
 the temporary materialization conversion is not applied\iref{conv.rval}
 and no result object is provided for the prvalue.
 The type of the prvalue may be incomplete or an abstract class type.
@@ -5868,9 +5882,9 @@
 
 \pnum
 An explicitly-defaulted function that is not defined as deleted may be declared
-\tcode{constexpr} only if it would have been implicitly declared as
-\tcode{constexpr}. If
-a function is explicitly defaulted on its first declaration,
+\tcode{constexpr} or \tcode{consteval} only
+if it would have been implicitly declared as \tcode{constexpr}.
+If a function is explicitly defaulted on its first declaration,
 it is implicitly considered to be \tcode{constexpr} if the implicit
 declaration would be.
 

source/expressions.tex

@@ -1279,6 +1279,12 @@
 \end{example}
 \end{itemize}
 
+\pnum
+An \grammarterm{id-expression}
+that denotes an immediate function\iref{dcl.constexpr}
+shall appear as a subexpression of an immediate invocation or
+in an immediate function context\iref{expr.const}.
+
 \pnum
 An \grammarterm{id-expression}
 that denotes the specialization of a concept\iref{temp.concept}
@@ -1532,7 +1538,7 @@
 \pnum
 In the \grammarterm{decl-specifier-seq} of the \grammarterm{lambda-declarator},
 each \grammarterm{decl-specifier}
-shall either be \tcode{mutable} or \tcode{constexpr}.
+shall be one of \tcode{mutable}, \tcode{constexpr}, or \tcode{consteval}.
 \begin{note}
 The trailing \grammarterm{requires-clause} is described in \ref{dcl.decl}.
 \end{note}
@@ -1658,8 +1664,12 @@
 The function call operator or any given operator template specialization
 is a constexpr function if either
 the corresponding \grammarterm{lambda-expression}{'s}
-\grammarterm{parameter-declaration-clause} is followed by \tcode{constexpr}, or
+\grammarterm{parameter-declaration-clause}
+is followed by \tcode{constexpr} or \tcode{consteval}, or
 it satisfies the requirements for a constexpr function\iref{dcl.constexpr}.
+It is an immediate function\iref{dcl.constexpr}
+if the corresponding \grammarterm{lambda-expression}{'s}
+\grammarterm{parameter-declaration-clause} is followed by \tcode{consteval}.
 \begin{note} Names referenced in
 the \grammarterm{lambda-declarator} are looked up in the context in which the
 \grammarterm{lambda-expression} appears. \end{note}
@@ -6802,8 +6812,12 @@
   if the value is of pointer type, it contains
   the address of an object with static storage duration,
   the address past the end of such an object\iref{expr.add},
-  the address of a function,
-  or a null pointer value, and
+  the address of a non-immediate function,
+  or a null pointer value,
+
+  \item
+  if the value is of pointer-to-member-function type,
+  it does not designate an immediate function, and
 
   \item
   if the value is an object of class or array type,
@@ -6813,8 +6827,18 @@
 \defnx{permitted result of a constant expression}{constant expression!permitted result of}
 if it is an
 object with static storage duration that is either not a temporary object or is
-a temporary object whose value satisfies the above constraints, or it is a
-function.
+a temporary object whose value satisfies the above constraints, or
+it is a non-immediate function.
+\begin{example}
+\begin{codeblock}
+consteval int f() { return 42; }
+consteval auto g() { return f; }
+consteval int h(int (*p)() = g()) { return p(); }
+constexpr int r = h();                          // OK
+constexpr auto e = g();                         // ill-formed: a pointer to an immediate function is
+                                                // not a permitted result of a constant expression
+\end{codeblock}
+\end{example}
 
 \pnum
 \begin{note} Since this document
@@ -6835,15 +6859,31 @@
 It is unspecified whether the value of \tcode{f()} will be \tcode{true} or \tcode{false}.
 \end{example} \end{note}%
 
+\pnum
+An expression or conversion is in an \defn{immediate function context}
+if it is potentially evaluated and
+its innermost non-block scope is
+a function parameter scope of an immediate function.
+An expression or conversion is an \defn{immediate invocation}
+if it is an explicit or implicit invocation of an immediate function and
+is not in an immediate function context.
+An immediate invocation shall be a constant expression.
+\begin{note}
+An immediate invocation is evaluated even in an unevaluated operand.
+\end{note}
+
 \pnum
 \indextext{expression!potentially constant evaluated}%
-An expression is \defn{potentially constant evaluated}
+An expression or conversion is \defn{potentially constant evaluated}
 if it is:
 
 \begin{itemize}
 \item
 a potentially-evaluated expression\iref{basic.def.odr},
 
+\item
+an immediate invocation,
+
 \item
 a \grammarterm{constraint-expression},
 including one formed from the \grammarterm{constraint-logical-or-expression}
@@ -6881,4 +6921,21 @@
 is of non-volatile const-qualified integral type or of reference type.
 \end{itemize}
 
+\begin{example}
+\begin{codeblock}
+struct N {
+  constexpr N() {}
+  N(N const&) = delete;
+};
+template<typename T> constexpr void bad_assert_copyable() { T t; T t2 = t; }
+using ineffective = decltype(bad_assert_copyable<N>());
+                        // \tcode{bad_assert_copyable<N>} is not needed for constant evaluation
+                        // (and thus not instantiated)
+template<typename T> consteval void assert_copyable() { T t; T t2 = t; }
+using check = decltype(assert_copyable<N>());
+                        // error: \tcode{assert_copyable<N>} is instantiated (because it is needed for constant
+                        // evaluation), but the attempt to copy \tcode{t} is ill-formed
+\end{codeblock}
+\end{example}
+
 \indextext{expression|)}

source/lex.tex

@@ -686,6 +686,7 @@
 \tcode{class}             \\
 \tcode{concept}           \\
 \tcode{const}             \\
+\tcode{consteval}         \\
 \tcode{constexpr}         \\
 \columnbreak
 \tcode{const_cast}        \\
@@ -703,8 +704,8 @@
 \tcode{extern}            \\
 \tcode{false}             \\
 \tcode{float}             \\
-\columnbreak
 \tcode{for}               \\
+\columnbreak
 \tcode{friend}            \\
 \tcode{goto}              \\
 \tcode{if}                \\
@@ -719,9 +720,9 @@
 \tcode{operator}          \\
 \tcode{private}           \\
 \tcode{protected}         \\
-\columnbreak
 \tcode{public}            \\
 \tcode{register}          \\
+\columnbreak
 \tcode{reinterpret_cast}  \\
 \tcode{requires}          \\
 \tcode{return}            \\
@@ -735,10 +736,10 @@
 \tcode{switch}            \\
 \tcode{template}          \\
 \tcode{this}              \\
-\columnbreak
 \tcode{thread_local}      \\
 \tcode{throw}             \\
 \tcode{true}              \\
+\columnbreak
 \tcode{try}               \\
 \tcode{typedef}           \\
 \tcode{typeid}            \\

source/templates.tex

@@ -6147,7 +6147,7 @@
 member function of a class template, or
 variable template
 shall not
-use the \tcode{inline} or \tcode{constexpr} specifiers.
+use the \tcode{inline}, \tcode{constexpr}, or \tcode{consteval} specifiers.
 
 \pnum
 The syntax for explicit instantiation is: