N3652 Relaxing constraints on constexpr functions

Conflicts resolved as indicated by N3652.

Author: zygoloid

source/basic.tex

@@ -2506,6 +2506,10 @@
 Variables with static storage duration~(\ref{basic.stc.static}) or thread storage
 duration~(\ref{basic.stc.thread}) shall be zero-initialized~(\ref{dcl.init}) before
 any other initialization takes place.
+A \term{constant initializer} for an object \tcode{o} is an expression that is a
+constant expression, except that it may also invoke \tcode{constexpr} constructors
+for \tcode{o} and its subobjects even if those objects are of non-literal class
+types \enternote such a class may have a non-trivial destructor \exitnote.
 
 \indextext{initialization!constant}%
 \term{Constant initialization} is performed:
@@ -2519,12 +2523,8 @@
 
 \item
 if an object with static or thread storage duration is initialized
-by a constructor call, if the constructor is a \tcode{constexpr} constructor, if all constructor
-arguments are constant expressions (including conversions), and if, after function
-invocation substitution~(\ref{dcl.constexpr}), every constructor call and full-expression in
-the \grammarterm{mem-initializer}{s}
-and in the \grammarterm{brace-or-equal-initializer}{s} for non-static data members
-is a constant expression;
+by a constructor call, and if the initialization full-expression is a constant
+initializer for the object;
 
 \item
 if an object with static or thread storage duration is not initialized by a constructor call
@@ -3549,16 +3549,14 @@
 A type is a \defn{literal type} if it is:
 
 \begin{itemize}
+\item \tcode{void}; or
 \item a scalar type; or
 \item a reference type; or
 \item an array of literal type other than an array of runtime bound; or
 \item a class type (Clause~\ref{class}) that
 has all of the following properties:
 \begin{itemize}
 \item it has a trivial destructor,
-\item every constructor call and full-expression in the
-\grammarterm{brace-or-equal-initializer}{s} for non-static data members
-(if any) is a constant expression~(\ref{expr.const}),
 \item it is an aggregate type~(\ref{dcl.init.aggr}) or has
 at least one \tcode{constexpr} constructor or constructor template that is not a copy or move constructor, and
 \item all of its non-static data members and base classes are

source/compatibility.tex

@@ -1299,6 +1299,34 @@
 }
 \end{codeblock}
 
+\rSec1[diff.cpp03]{\Cpp and ISO \CppXI}
+
+\pnum
+\indextext{summary!compatibility~with ISO \CppXI}%
+This subclause lists the differences between \Cpp and
+ISO \CppXI (ISO/IEC 14882:2011, \doccite{Programming Languages --- \Cpp}),
+by the chapters of this document.
+
+\rSec2[diff.cpp11.dcl.dcl]{Clause \ref{dcl.dcl}: declarations}
+
+\ref{dcl.constexpr}
+\change \tcode{constexpr} non-static member functions are not implicitly
+\tcode{const} member functions.
+\rationale Necessary to allow \tcode{constexpr} member functions to mutate
+the object.
+\effect
+Valid \CppXI code may fail to compile in this International Standard.
+For example, the following code is valid in \CppXI
+but invalid in this International Standard because it declares the same member
+function twice with different return types:
+
+\begin{codeblock}
+struct S {
+  constexpr const int &f();
+  int &f();
+};
+\end{codeblock}
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \rSec1[diff.library]{C standard library}
 \indextext{library!C standard}%

source/declarations.tex

@@ -752,21 +752,21 @@
 Function parameters cannot be declared \tcode{constexpr}.\exitnote
 \enterexample
 \begin{codeblock}
-constexpr int square(int x);    // OK: declaration
+constexpr void square(int &x);  // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: \tcode{pixel} is a type
   int x;
   int y;
   constexpr pixel(int);         // OK: declaration
 }; 
 constexpr pixel::pixel(int a)
-  : x(square(a)), y(square(a))  // OK: definition
-  { }
+  : x(a), y(x)                  // OK: definition
+  { square(x); }
 constexpr pixel small(2);       // error: \tcode{square} not defined, so \tcode{small(2)}
                                 // not constant~(\ref{expr.const}) so \tcode{constexpr} not satisfied
 
-constexpr int square(int x) {   // OK: definition
-  return x * x;
+constexpr void square(int &x) { // OK: definition
+  x *= x;
 }
 constexpr pixel large(4);       // OK: \tcode{square} defined
 int next(constexpr int x) {     // error: not for parameters
@@ -806,16 +806,16 @@
 its \grammarterm{function-body} shall be
 \tcode{= delete}, \tcode{= default}, or
 a \grammarterm{compound-statement}
-that contains only
+that does not contain
 
 \begin{itemize}
-\item null statements,
-\item \grammarterm{static_assert-declaration}{s}
-\item \tcode{typedef} declarations and \grammarterm{alias-declaration}{s} that
-do not define classes or enumerations,
-\item \grammarterm{using-declaration}{s},
-\item \grammarterm{using-directive}{s},
-\item and exactly one return statement.
+\item an \grammarterm{asm-definition},
+\item a \tcode{goto} statement,
+\item a \grammarterm{try-block}, or
+\item a definition of a variable
+of non-literal type or
+of static or thread storage duration or
+for which no initialization is performed.
 \end{itemize}
 
 \end{itemize}
@@ -826,13 +826,22 @@
   { return x * x; }             // OK
 constexpr long long_max() 
   { return 2147483647; }        // OK
-constexpr int abs(int x) 
-  { return x < 0 ? -x : x; }    // OK 
-constexpr void f(int x)         // error: return type is \tcode{void}
-  { /* ... */ }
+constexpr int abs(int x) {
+  if (x < 0)
+    x = -x;
+  return x;                     // OK
+}
+constexpr int first(int n) {
+  static int value = n;         // error: variable has static storage duration
+  return value;
+}
+constexpr int uninit() {
+  int a;                        // error: variable is uninitialized
+  return a;
+}
 constexpr int prev(int x)
-  { return --x; }               // error: use of decrement
-constexpr int g(int x, int n) { // error: body not just ``return expr''
+  { return --x; }               // OK
+constexpr int g(int x, int n) { // OK
   int r = 1;
   while (--n > 0) r *= x;
   return r;
@@ -862,16 +871,8 @@
 \begin{itemize}
 \item
 either its \grammarterm{function-body} shall be \tcode{= default}, or the \grammarterm{compound-statement} of its \grammarterm{function-body}
-shall contain only
-
-\begin{itemize}
-\item null statements,
-\item \grammarterm{static_assert-declaration}{s}
-\item \tcode{typedef} declarations and \grammarterm{alias-declaration}{s} that
-do not define classes or enumerations,
-\item \grammarterm{using-declaration}{s},
-\item and \grammarterm{using-directive}{s};
-\end{itemize}
+shall satisfy the constraints for a \grammarterm{function-body} of a
+\tcode{constexpr} function;
 
 \item
 every non-variant non-static data member and base class sub-object
@@ -884,79 +885,26 @@
 
 \item
 every constructor involved in initializing non-static
-data members and base class sub-objects shall be a \tcode{constexpr} constructor;
-
-\item
-every \grammarterm{assignment-expression} that is an \grammarterm{initializer-clause}
-appearing directly or indirectly within a \grammarterm{brace-or-equal-initializer}
-for a non-static data member that is not named by a \grammarterm{mem-initializer-id}
-shall be a constant expression.
+data members and base class sub-objects shall be a \tcode{constexpr} constructor.
 \end{itemize}
 
 \enterexample
 \begin{codeblock}
 struct Length { 
   explicit constexpr Length(int i = 0) : val(i) { }
 private: 
-    int val; 
+  int val; 
 }; 
 \end{codeblock}
 \exitexample
 
 \pnum
-\indexdefn{function invocation substitution}\term{Function invocation substitution}
-for a call of a \tcode{constexpr} function or
-of a \tcode{constexpr} constructor means:
-
-\begin{itemize}
-
-\item
-implicitly converting each argument to the corresponding parameter
-type as if by copy-initialization,\footnote{The resulting converted
-value will include an lvalue-to-rvalue conversion~(\ref{conv.lval}) if
-the corresponding copy-initialization requires one.}
-
-\item
-substituting that converted expression for each use of the corresponding parameter in the
-\grammarterm{function-body},
-
-\item
-in a member function, substituting for each use of
-\tcode{this}~(\ref{class.this}) a prvalue pointer whose value is the
-address of the object for which the member function is called, and
-
-\item
-in a \tcode{constexpr} function, implicitly converting the resulting
-returned expression or \grammarterm{braced-init-list} to the
-return type of the function as if by copy-initialization.
-\end{itemize}
-
-Such substitution does not change the
-meaning. \enterexample
-\begin{codeblock}
-constexpr int f(void *) { return 0; }
-constexpr int f(...) { return 1; }
-constexpr int g1() { return f(0); }         // calls \tcode{f(void *)}
-constexpr int g2(int n) { return f(n); }    // calls \tcode{f(...)} even for \tcode{n == 0}
-constexpr int g3(int n) { return f(n*0); }  // calls \tcode{f(...)}
-
-namespace N {
-  constexpr int c = 5;
-  constexpr int h() { return c; }
-}
-constexpr int c = 0;
-constexpr int g4() { return N::h(); }       // value is \tcode{5}, \tcode{c} is not looked up again after the substitution
-\end{codeblock}
-\exitexample
-
-For a non-template, non-defaulted \tcode{constexpr} function, if no function
-argument values exist such that the function
-invocation substitution would produce a constant expression~(\ref{expr.const}), the
-program is ill-formed; no diagnostic required. For a non-template,
-non-defaulted, non-inheriting \tcode{constexpr} constructor, if no
-argument values exist such that after function invocation substitution, every constructor
-call and full-expression in the \grammarterm{mem-initializer}{s} would be a constant
-expression (including conversions), the program is ill-formed; no diagnostic required.
+For a non-template, non-defaulted
+\tcode{constexpr} function or a non-template, non-defaulted, non-inheriting
+\tcode{constexpr} constructor, if no argument values exist such that
+an invocation of the function or constructor could be an evaluated subexpression of a core
+constant expression~(\ref{expr.const}), the program is ill-formed; no diagnostic
+required.
 \enterexample
 \begin{codeblock}
 constexpr int f(bool b)
@@ -998,21 +946,16 @@
 function can appear in a constant expression.
 
 \pnum
-A \tcode{constexpr} specifier for a non-static member
-function that is not a constructor declares that member function to be
-\tcode{const}~(\ref{class.mfct.non-static}).
-\enternote The \tcode{constexpr} specifier has no
-other effect on the function type.\exitnote
-The keyword \tcode{const} is ignored if it appears in the \grammarterm{cv-qualifier-seq}
-of the function declarator of the declaration of such a member function.
+The \tcode{constexpr} specifier has no
+effect on the type of a \tcode{constexpr} function or a \tcode{constexpr} constructor.
 The class of
-which that function is a member shall be a literal
+which a \tcode{constexpr} function is a member shall be a literal
 type~(\ref{basic.types}). \enterexample
 \begin{codeblock}
 class debug_flag { 
 public: 
   explicit debug_flag(bool); 
-  constexpr bool is_on();       // error: \tcode{debug_flag} not 
+  constexpr bool is_on() const; // error: \tcode{debug_flag} not 
                                 // literal type 
 private: 
   bool flag; 
@@ -1035,10 +978,9 @@
 that call shall be a constant expression~(\ref{expr.const}).
 Otherwise,
 or if a \tcode{constexpr} specifier is used in a reference declaration,
-every full-expression that appears in its initializer shall be a constant expression. Each
+every full-expression that appears in its initializer shall be a constant expression. \enternote Each
 implicit conversion used in converting the initializer expressions and each constructor call
-used for the initialization shall be one of those allowed in a constant
-expression~(\ref{expr.const}).
+used for the initialization is part of such a full-expression. \exitnote
 \enterexample
 \begin{codeblock}
 struct pixel {