Merge 2018-06 CWG Motion 2

Fixes #2114

Author: zygoloid

source/basic.tex

@@ -808,9 +808,14 @@
 
 \pnum
 The point of declaration for a function-local predefined
-variable\iref{dcl.fct.def} is immediately before the
+variable\iref{dcl.fct.def.general} is immediately before the
 \grammarterm{function-body} of a function definition.
 
+\pnum
+The point of declaration of a structured binding\iref{dcl.struct.bind}
+is immediately after
+the \grammarterm{identifier-list} of the structured binding declaration.
+
 \pnum
 The point of declaration for the variable or the structured bindings
 declared in the \grammarterm{for-range-declaration}

source/declarators.tex

@@ -1644,7 +1644,10 @@
 \grammarterm{parameter-declaration}{} this
 \grammarterm{initializer-clause}{}
 is used as a default argument.
-Default arguments will be used in calls where trailing arguments are missing.
+\begin{note}
+Default arguments will be used in calls
+where trailing arguments are missing\iref{expr.call}.
+\end{note}
 
 \pnum
 \indextext{argument!example of default}%
@@ -1709,7 +1712,8 @@
 In
 a given function declaration, each parameter subsequent to a
 parameter with a default argument shall have a default argument
-supplied in this or a previous declaration
+supplied in this or a previous declaration,
+unless the parameter was expanded from a parameter pack,
 or shall be a function parameter pack.
 A default argument
 shall not be redefined by a later declaration (not even to the
@@ -1735,6 +1739,10 @@
 void n() {
   f(6);                         // OK, calls \tcode{f(6, 7)}
 }
+template<class ... T> struct C {
+  void f(int n = 0, T...);
+};
+C<int> c;                       // OK, instantiates declaration \tcode{void C::f(int n = 0, int)}
 \end{codeblock}
 \end{example}
 For a given inline function defined in different translation units,
@@ -2289,6 +2297,11 @@
 \tcode{E} is never a reference type\iref{expr.prop}.
 \end{note}
 
+\pnum
+If the \grammarterm{initializer} refers to
+one of the names introduced by the structured binding declaration,
+the program is ill-formed.
+
 \pnum
 If \tcode{E} is an array type with element type \tcode{T}, the number
 of elements in the \grammarterm{identifier-list} shall be equal to the
@@ -3004,7 +3017,7 @@
 \item
 Otherwise, the element is copy-initialized
 from the corresponding \grammarterm{initializer-clause}
-or the \grammarterm{brace-or-equal-initializer}
+or is initialized with the \grammarterm{brace-or-equal-initializer}
 of the corresponding \grammarterm{designated-initializer-clause}.
 If that initializer is of the form
 \grammarterm{assignment-expression} or

source/expressions.tex

@@ -677,8 +677,10 @@
 
 \pnum
 \indextext{identifier}%
-An \grammarterm{identifier} is an \grammarterm{id-expression} provided it has
-been suitably declared\iref{dcl.dcl}.
+An \grammarterm{identifier} is only
+an \grammarterm{id-expression} if it has
+been suitably declared\iref{dcl.dcl}
+or if it appears as part of a \grammarterm{declarator-id}\iref{dcl.decl}.
 \begin{note}
 For \grammarterm{operator-function-id}{s}, see~\ref{over.oper}; for
 \grammarterm{conversion-function-id}{s}, see~\ref{class.conv.fct}; for
@@ -2237,12 +2239,21 @@
 \indextext{function argument|see{argument}}%
 \indextext{function parameter|see{parameter}}%
 \indextext{initialization!parameter}%
-When a function is called, each parameter\iref{dcl.fct} shall be
+When a function is called, each parameter\iref{dcl.fct} is
 initialized~(\ref{dcl.init}, \ref{class.copy}, \ref{class.ctor}) with
 its corresponding argument.
+If there is no corresponding argument,
+the default argument for the parameter is used;
+the program is ill-formed if one is not present.
+\begin{example}
+\begin{codeblock}
+  template<typename ...T> int f(int n = 0, T ...t);
+  int x = f<int>();             // error: no argument for second function parameter
+\end{codeblock}
+\end{example}
 If the function is a non-static member
 function, the \tcode{this} parameter of the function\iref{class.this}
-shall be initialized with a pointer to the object of the call, converted
+is initialized with a pointer to the object of the call, converted
 as if by an explicit type conversion\iref{expr.cast}.
 \begin{note}
 There is no access or ambiguity checking on this conversion; the access
@@ -2431,7 +2442,7 @@
 expression\iref{expr.cast}.
 \indextext{type!incomplete}%
 Otherwise, if the type is \cv{}~\tcode{void}
-and the initializer is \tcode{()}
+and the initializer is \tcode{()} or \tcode{\{\}}
 (after pack expansion, if any),
 the expression is a prvalue of the specified type
 that performs no initialization.

source/overloading.tex

@@ -630,8 +630,36 @@
 
 \pnum
 A defaulted move special function\iref{class.copy} that is
-defined as deleted is excluded from the set of candidate functions in all
-contexts.
+defined as deleted is excluded from the set of candidate functions
+in all contexts.
+A constructor inherited from class type \tcode{C}\iref{class.inhctor.init}
+that has a first parameter of type ``reference to \cvqual{cv1} \tcode{P}''
+(including such a constructor instantiated from a template)
+is excluded from the set of candidate functions
+when constructing an object of type \cvqual{cv2} \tcode{D}
+if the argument list has exactly one argument and
+\tcode{C} is reference-related to \tcode{P} and
+\tcode{P} is reference-related to \tcode{D}.
+\begin{example}
+\begin{codeblock}
+struct A {
+  A();
+  A(A &&);                              // \#1
+  template<typename T> A(T &&);         // \#2
+};
+struct B : A {
+  using A::A;
+  B(const B &);                         // \#3
+  B(B &&) = default;                    // \#4, implicitly deleted
+
+  struct X { X(X &&) = delete; } x;
+};
+extern B b1;
+B b2 = static_cast<B&&>(b1);            // calls \#3: \#1, \#2, and \#4 are not viable
+struct C { operator B&&(); };
+B b3 = C();                             // calls \#3
+\end{codeblock}
+\end{example}
 
 \rSec3[over.match.call]{Function call syntax}%
 \indextext{overloading!resolution!function call syntax|(}