Merge 2018-06 CWG Motion 16

Fixes #2128

Author: zygoloid

source/compatibility.tex

@@ -1917,6 +1917,27 @@
 
 \rSec2[diff.cpp17.special]{\ref{special}: special member functions}
 
+\diffrefs{class.ctor}{class.conv.fct}
+\change
+The class name can no longer be used parenthesized
+immediately after an \tcode{explicit} \grammarterm{decl-specifier}
+in a constructor declaration.
+The \grammarterm{conversion-function-id} can no longer be used parenthesized
+immediately after an \tcode{explicit} \grammarterm{decl-specifier}
+in a conversion function declaration.
+\rationale
+Necessary for new functionality.
+\effect
+Valid \CppXVII{} code may fail to compile
+in this International Standard. For example:
+\begin{codeblock}
+struct S {
+  explicit (S)(const S&);       // ill-formed; previously well-formed
+  explicit (operator int)();    // ill-formed; previously well-formed
+  explicit(true) (S)(int);      // OK
+};
+\end{codeblock}
+
 \diffrefs{class.ctor}{class.dtor}
 \change
 A \grammarterm{simple-template-id}

source/declarations.tex

@@ -499,6 +499,12 @@
 \begin{bnf}
 \nontermdef{function-specifier}\br
     \terminal{virtual}\br
+    explicit-specifier
+\end{bnf}
+
+\begin{bnf}
+\nontermdef{explicit-specifier}\br
+    \terminal{explicit} \terminal{(} constant-expression \terminal{)}\br
     \terminal{explicit}
 \end{bnf}
 
@@ -510,10 +516,22 @@
 
 \pnum
 \indextext{specifier!\idxcode{explicit}}%
-The \tcode{explicit} specifier shall be used only in the declaration of
+An \grammarterm{explicit-specifier} shall be used only in the declaration of
 a constructor or conversion function within its class definition;
 see~\ref{class.conv.ctor} and~\ref{class.conv.fct}.
 
+\pnum
+In an \grammarterm{explicit-specifier},
+the \grammarterm{constant-expression}, if supplied, shall be a
+contextually converted constant expression of type \tcode{bool}\iref{expr.const}.
+The \grammarterm{explicit-specifier} \tcode{explicit}
+without a \grammarterm{constant-expression} is equivalent to
+the \grammarterm{explicit-specifier} \tcode{explicit(true)}.
+If the constant expression evaluates to \tcode{true},
+the function is explicit. Otherwise, the function is not explicit.
+A \tcode{(} token that follows \tcode{explicit} is parsed as
+part of the \grammarterm{explicit-specifier}.
+
 \rSec2[dcl.typedef]{The \tcode{typedef} specifier}%
 \indextext{specifier!\idxcode{typedef}}
 

source/declarators.tex

@@ -440,10 +440,11 @@
 \tcode{inline},
 \tcode{virtual},
 \tcode{constexpr},
-\tcode{explicit},
 or
 \tcode{typedef}
-specifier applies directly to each \grammarterm{declarator-id}
+specifier
+or an \grammarterm{explicit-specifier}
+applies directly to each \grammarterm{declarator-id}
 in an \grammarterm{init-declarator-list} or \grammarterm{member-declarator-list};
 the type specified for each \grammarterm{declarator-id} depends on
 both the \grammarterm{decl-specifier-seq} and its \grammarterm{declarator}.

source/lib-intro.tex

@@ -834,13 +834,6 @@
 the implementation provides explicit definitions for such member function
 signatures, or for virtual destructors that can be generated by default.
 
-\pnum
-For the sake of exposition, the library clauses sometimes annotate
-constructors with \EXPLICIT{}. Such a constructor is conditionally declared
-as either explicit or non-explicit\iref{class.conv.ctor}.
-\begin{note} This is typically implemented by declaring two such constructors,
-of which at most one participates in overload resolution. \end{note}
-
 \rSec3[operators]{Operators}
 
 \pnum

source/macros.tex

@@ -290,8 +290,6 @@
 \newcommand{\unspecuniqtype}{\UNSP{unspecified unique type}}
 \newcommand{\unspecalloctype}{\UNSP{unspecified allocator type}}
 
-\newcommand{\EXPLICIT}{\textit{\texttt{EXPLICIT}\nocorr}}
-
 %% Manual insertion of italic corrections, for aligning in the presence
 %% of the above annotations.
 \newlength{\itcorrwidth}

source/overloading.tex

@@ -609,6 +609,13 @@
 function template specializations
 are generated using template argument deduction~(\ref{temp.over},
 \ref{temp.deduct}).
+If a constructor template or conversion function template
+has an \grammarterm{explicit-specifier}
+whose \grammarterm{constant-expression} is value-dependent\iref{temp.dep},
+template argument deduction is performed first and then,
+if the context requires a candidate that
+is not explicit and the generated specialization is explicit\iref{dcl.fct.spec},
+it will be removed from the candidate set.
 Those candidates are then handled as candidate
 functions in the usual way.\footnote{The process of argument deduction fully
 determines the parameter types of
@@ -1436,7 +1443,7 @@
 
 If the initializer list has no elements and \tcode{T} has a default constructor,
 the first phase is omitted.
-In copy-list-initialization, if an \tcode{explicit} constructor is
+In copy-list-initialization, if an explicit constructor is
 chosen, the initialization is ill-formed. \begin{note}
 This differs from other situations~(\ref{over.match.ctor}, \ref{over.match.copy}),
 where only converting constructors are considered for copy-initialization.
@@ -1514,10 +1521,11 @@
 a single expression of type \cv{}~\tcode{U},
 where \tcode{U} is a specialization of \tcode{C} or
 a class derived from a specialization of \tcode{C}.
-Each such notional constructor
-is considered to be explicit if the function or function template was
-generated from a constructor or \grammarterm{deduction-guide} that was
-declared \tcode{explicit}.
+If the function or function template was generated from
+a constructor or \grammarterm{deduction-guide}
+that had an \grammarterm{explicit-specifier},
+each such notional constructor is considered to have
+that same \grammarterm{explicit-specifier}.
 All such notional constructors are considered to be
 public members of the hypothetical class type.
 

source/special.tex

@@ -103,7 +103,7 @@
 The \grammarterm{class-name} shall not be a \grammarterm{typedef-name}. In a constructor
 declaration, each \grammarterm{decl-specifier} in the optional
 \grammarterm{decl-specifier-seq} shall be \tcode{friend}, \tcode{inline},
-\tcode{explicit}, or \tcode{constexpr}.
+\tcode{constexpr}, or an \grammarterm{explicit-specifier}.
 \begin{example}
 
 \begin{codeblock}
@@ -793,9 +793,7 @@
 \indextext{conversion!user-defined}%
 
 \pnum
-A constructor declared without the
-\grammarterm{function-specifier}
-\tcode{explicit}
+A constructor that is not explicit\iref{dcl.fct.spec}
 specifies a conversion from
 the types of its parameters (if any)
 to the type of its class.

source/templates.tex

@@ -7238,9 +7238,11 @@
 as part of the substitution
 process.
 \end{note}
-Only invalid types and expressions in the immediate
-context of the function type and its template parameter types can result in a deduction
-failure.
+Only invalid types and expressions in the immediate context of
+the function type,
+its template parameter types,
+and its \grammarterm{explicit-specifier}
+can result in a deduction failure.
 \begin{note}
 The substitution into types and expressions can result
 in effects such as the instantiation of class template specializations and/or