Merge 2017-03 CWG Motion 8

Author: zygoloid

source/declarations.tex

@@ -1277,17 +1277,14 @@
 \indextext{type specifier!\idxcode{decltype}}%
 \indextext{\idxgram{type-name}}%
 \indextext{\idxgram{lambda-introducer}}%
-The \grammarterm{simple-type-specifier} \tcode{auto} is a placeholder for a type to be
-deduced~(\ref{dcl.spec.auto}).
+The \grammarterm{simple-type-specifier} \tcode{auto}
+is a placeholder for
+a type to be deduced~(\ref{dcl.spec.auto}).
 \indextext{deduction!class template arguments}%
 A \grammarterm{type-specifier} of the form
 \tcode{typename}\opt{} \grammarterm{nested-name-specifier}\opt{} \grammarterm{template-name}
-is a placeholder for a deduced class type
-and shall appear only as a \grammarterm{decl-specifier}
-in the \grammarterm{decl-specifier-seq}
-of a \grammarterm{simple-declaration}~(\ref{dcl.type.class.deduct})
-or as the \grammarterm{simple-type-specifier}
-in an explicit type conversion (functional notation)~(\ref{expr.type.conv}).
+is a placeholder for
+a deduced class type~(\ref{dcl.type.class.deduct}).
 The \grammarterm{template-name} shall name a class template
 that is not an injected-class-name.
 The other
@@ -1578,20 +1575,22 @@
 
 \pnum
 The type of a variable declared using \tcode{auto} or \tcode{decltype(auto)} is
-deduced from its initializer. This use is allowed when declaring variables in a
-block~(\ref{stmt.block}), in
-namespace scope~(\ref{basic.scope.namespace}), and in an
-\grammarterm{init-statement} (Clause~\ref{stmt.stmt}).
+deduced from its initializer.
+This use is allowed
+in an initializing declaration~(\ref{dcl.init}) of a variable.
 \tcode{auto} or \tcode{decltype(auto)} shall appear as one of the
 \grammarterm{decl-specifier}{s} in the
 \grammarterm{decl-specifier-seq} and the
 \grammarterm{decl-specifier-seq}
-shall be followed by one or more \grammarterm{init-declarator}{s}, each of which shall
-have a non-empty \grammarterm{initializer}. In an
-\grammarterm{initializer} of the form
+shall be followed by one or more
+\grammarterm{declarator}{s},
+each of which shall
+be followed by a non-empty
+\grammarterm{initializer}.
+In an \grammarterm{initializer} of the form
 
 \begin{codeblock}
-( @\grammarterm{expression-list}@ )
+( @\textrm{\grammarterm{expression-list}}@ )
 \end{codeblock}
 
 the \grammarterm{expression-list} shall be a single
@@ -1609,15 +1608,10 @@
 \end{example}
 
 \pnum
-A placeholder type can also be used in declaring a variable in
-the \grammarterm{condition} of a selection statement~(\ref{stmt.select}) or an iteration
-statement~(\ref{stmt.iter}), in the \grammarterm{type-specifier-seq} in
+A placeholder type can also be used
+in the \grammarterm{type-specifier-seq} in
 the \grammarterm{new-type-id} or \grammarterm{type-id} of a
-\grammarterm{new-expression}~(\ref{expr.new}), in a
-\grammarterm{for-range-declaration},
-in declaring a static data member with a
-\grammarterm{brace-or-equal-initializer} that appears within the
-\grammarterm{member-specification} of a class definition~(\ref{class.static.data}),
+\grammarterm{new-expression}~(\ref{expr.new})
 and as a \grammarterm{decl-specifier}
 of the \grammarterm{parameter-declaration}{'s}
 \grammarterm{decl-specifier-seq}
@@ -1866,21 +1860,29 @@
 If a placeholder for a deduced class type
 appears as a \grammarterm{decl-specifier}
 in the \grammarterm{decl-specifier-seq}
-of a \grammarterm{simple-declaration},
-the \grammarterm{init-declarator}
-of that declaration
-shall be of the form
-
-\begin{ncbnf}
-    declarator-id attribute-specifier-seq\opt{} initializer
-\end{ncbnf}
-
-The placeholder is replaced by the return type
+of an initializing declaration~(\ref{dcl.init}) of a variable,
+the placeholder is replaced by the return type
 of the function selected by overload resolution
 for class template deduction~(\ref{over.match.class.deduct}).
-If the \grammarterm{init-declarator-list}
-contains more than one \grammarterm{init-declarator},
+If the \grammarterm{decl-specifier-seq}
+is followed by an \grammarterm{init-declarator-list}
+or \grammarterm{member-declarator-list}
+containing more than one \grammarterm{declarator},
 the type that replaces the placeholder shall be the same in each deduction.
+
+\pnum
+A placeholder for a deduced class type
+can also be used
+in the \grammarterm{type-specifier-seq}
+in the \grammarterm{new-type-id} or \grammarterm{type-id}
+of a \grammarterm{new-expression}~(\ref{expr.new}),
+or
+as the \grammarterm{simple-type-specifier}
+in an explicit type conversion (functional notation)~(\ref{expr.type.conv}).
+A placeholder for a deduced class type
+shall not appear in any other context.
+
+\pnum
 \begin{example}
 \begin{codeblock}
 template<class T> struct container {

source/declarators.tex

@@ -2908,6 +2908,19 @@
 or by an inherited constructor~(\ref{class.inhctor.init}).
 \end{note}
 
+\pnum
+A declaration that specifies the initialization of a variable,
+whether from an explicit initializer or by default-initialization,
+is called the \defn{initializing declaration} of that variable.
+\begin{note}
+In most cases
+this is the defining declaration~(\ref{basic.def}) of the variable,
+but the initializing declaration
+of a non-inline static data member~(\ref{class.static.data})
+might be the declaration within the class definition
+and not the definition at namespace scope.
+\end{note}
+
 \rSec2[dcl.init.aggr]{Aggregates}%
 \indextext{aggregate}%
 \indextext{initialization!aggregate}%

source/expressions.tex

@@ -3061,28 +3061,26 @@
 If a placeholder type~(\ref{dcl.spec.auto}) appears in the
 \grammarterm{type-specifier-seq} of a \grammarterm{new-type-id} or
 \grammarterm{type-id} of a \grammarterm{new-expression},
-the \grammarterm{new-expression} shall contain a
-\grammarterm{new-initializer} of the form
-
-\begin{ncsimplebnf}
-\terminal{(} assignment-expression \terminal{)}
-\end{ncsimplebnf}
-
-The allocated type is deduced from the \grammarterm{new-initializer} as
-follows: Let \tcode{e} be the \grammarterm{assignment-expression} in the \grammarterm{new-initializer} and
+the allocated type is deduced as follows:
+Let
+\placeholder{init} be the \grammarterm{new-initializer}, if any,
+and
 \tcode{T} be the \grammarterm{new-type-id} or \grammarterm{type-id} of
 the \grammarterm{new-expression}, then the allocated type is the type
 deduced for the variable \tcode{x} in the invented
 declaration~(\ref{dcl.spec.auto}):
 
 \begin{codeblock}
-T x(e);
+T x @\textrm{\placeholder{init}}@ ;
 \end{codeblock}
 
 \begin{example}
 \begin{codeblock}
 new auto(1);                    // allocated type is \tcode{int}
 auto x = new auto('a');         // allocated type is \tcode{char}, \tcode{x} is of type \tcode{char*}
+
+template<class T> struct A { A(T, T); };
+auto y = new A{1, 2};           // allocated type is \tcode{A<int>}
 \end{codeblock}
 \end{example}
 

source/overloading.tex

@@ -1392,8 +1392,9 @@
 \begin{itemize}
 \item
 For each constructor
-of the class template
+of the primary class template
 designated by the \grammarterm{template-name},
+if the template is defined,
 a function template with the following properties:
 \begin{itemize}
 \item
@@ -1411,6 +1412,17 @@
 obtained from the class template.
 \end{itemize}
 
+\item
+If the primary class template \tcode{C}
+is not defined or does not declare any constructors,
+an additional function template derived as above
+from a hypothetical constructor \tcode{C()}.
+
+\item
+An additional function template derived as above
+from a hypothetical constructor \tcode{C(C)},
+called the \defn{copy deduction candidate}.
+
 \item
 For each \grammarterm{deduction-guide},
 a function or function template
@@ -1440,6 +1452,8 @@
 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}.
+All such notional constructors are considered to be
+public members of the hypothetical class type.
 
 \pnum
 \begin{example}
@@ -1640,26 +1654,6 @@
 \end{example}
 or, if not that,
 
-\item
-\tcode{F1} is generated from a
-\grammarterm{deduction-guide}~(\ref{over.match.class.deduct})
-and \tcode{F2} is not
-\begin{example}
-\begin{codeblock}
-template <class T> struct A {
-  A(T, int*);       // \#1
-  A(A<T>&, int*);   // \#2
-  enum { value };
-};
-
-template <class T, int N = T::value> A(T&&, int*) -> A<T>;  // \#3
-
-A a{1, 0};          // uses \#1 to deduce \tcode{A<int>} and initializes with \#1
-A b{a, 0};          // uses \#3 (not \#2) to deduce \tcode{A<A<int>\&>} and initializes with \#1
-\end{codeblock}
-\end{example}
-or, if not that,
-
 \item
 \tcode{F1}
 is not a function template specialization and
@@ -1679,7 +1673,47 @@
 \tcode{F1}
 is more specialized than the template for
 \tcode{F2}
-according to the partial ordering rules described in~\ref{temp.func.order}.
+according to the partial ordering rules described in~\ref{temp.func.order},
+or, if not that,
+
+\item
+\tcode{F1} is generated from a
+\grammarterm{deduction-guide}~(\ref{over.match.class.deduct})
+and \tcode{F2} is not, or, if not that,
+
+\item
+\tcode{F1} is the copy deduction candidate~(\ref{over.match.class.deduct})
+and \tcode{F2} is not, or, if not that,
+
+\item
+\tcode{F1} is generated from a non-template constructor
+and \tcode{F2} is generated from a constructor template.
+\begin{example}
+\begin{codeblock}
+template <class T> struct A {
+  using value_type = T;
+  A(value_type);    // \#1
+  A(const A&);      // \#2
+  A(T, T, int);     // \#3
+  template<class U>
+    A(int, T, U);   // \#4
+  // \#5 is the copy deduction candidate, \tcode{A(A)}
+};
+
+A x(1, 2, 3);       // uses \#3, generated from a non-template constructor
+
+template <class T>
+A(T) -> A<T>;       // \#6, less specialized than \#5
+
+A a(42);            // uses \#6 to deduce \tcode{A<int>} and \#1 to initialize
+A b = a;            // uses \#5 to deduce \tcode{A<int>} and \#2 to initialize
+
+template <class T>
+A(A<T>) -> A<A<T>>; // \#7, as specialized as \#5
+
+A b2 = a;           // uses \#7 to deduce \tcode{A<A<int>>} and \#1 to initialize
+\end{codeblock}
+\end{example}
 \end{itemize}
 
 \pnum

source/templates.tex

@@ -7657,6 +7657,11 @@
 A \grammarterm{deduction-guide}
 shall be declared
 in the same scope
-as the corresponding class template.
+as the corresponding class template
+and, for a member class template, with the same access.
+Two deduction guide declarations
+in the same translation unit
+for the same class template
+shall not have equivalent \grammarterm{parameter-declaration-clause}{s}.
 
 \indextext{template|)}