Merge 2017-07 CWG Motion 2

Author: zygoloid

source/basic.tex

@@ -722,6 +722,12 @@
 variable~(\ref{dcl.fct.def}) is immediately before the
 \grammarterm{function-body} of a function definition.
 
+\pnum
+The point of declaration for the variable or the structured bindings
+declared in the \grammarterm{for-range-declaration}
+of a range-based \tcode{for} statement~(\ref{stmt.ranged})
+is immediately after the \grammarterm{for-range-initializer}.
+
 \pnum
 The point of declaration for a template parameter is immediately after its complete
 \grammarterm{template-parameter}. \begin{example}
@@ -4061,7 +4067,7 @@
 \item
 they are the same object, or
 \item
-one is a standard-layout union object and
+one is a union object and
 the other is a non-static data member of that object~(\ref{class.union}), or
 \item
 one is a standard-layout class object and

source/classes.tex

@@ -1525,9 +1525,9 @@
 of its non-static data members. Each non-static data member is allocated
 as if it were the sole member of a struct.
 \begin{note}
-A standard-layout union object and its non-static data members are
+A union object and its non-static data members are
 pointer-interconvertible~(\ref{basic.compound}, \ref{expr.static.cast}).
-As a consequence, all non-static data members of such a
+As a consequence, all non-static data members of a
 union object have the same address.
 \end{note}
 

source/declarations.tex

@@ -3022,7 +3022,8 @@
 
 \pnum
 \indextext{overloading!using-declaration and}%
-For the purpose of overload resolution, the functions that are
+For the purpose of forming a set of candidates during overload resolution,
+the functions that are
 introduced by a \grammarterm{using-declaration} into a derived class
 are treated as though they were members of the derived class. In
 particular, the implicit \tcode{this} parameter shall be treated as if
@@ -3037,6 +3038,10 @@
 of an object of class type, all subobjects other than the base class
 from which the constructor originated
 are implicitly initialized~(\ref{class.inhctor.init}).
+\begin{note}
+A member of a derived class is sometimes preferred to a member of a base class
+if they would otherwise be ambiguous~(\ref{over.match.best}).
+\end{note}
 
 \pnum
 \indextext{access control!using-declaration and}%

source/expressions.tex

@@ -376,11 +376,12 @@
 the declaration of a static member function (although its type and value category
 are defined within a static member function as they are within a non-static
 member function). \begin{note} This is because declaration matching does not
-occur until the complete declarator is known. \end{note} Unlike the object
-expression in other contexts, \tcode{*this} is not required to be of complete
-type for purposes of class member access~(\ref{expr.ref}) outside the member
-function body. \begin{note} Only class members declared prior to the declaration
-are visible. \end{note}
+occur until the complete declarator is known. \end{note}
+\begin{note}
+In a \grammarterm{trailing-return-type},
+the class being defined is not required to be complete
+for purposes of class member access~(\ref{expr.ref}).
+Class members declared later are not visible.
 \begin{example}
 \begin{codeblock}
 struct A {
@@ -391,6 +392,7 @@
 template auto A::f(int t) -> decltype(t + g());
 \end{codeblock}
 \end{example}
+\end{note}
 
 \pnum
 Otherwise, if a \grammarterm{member-declarator} declares a non-static data
@@ -1843,9 +1845,15 @@
 \pnum
 \indextext{type!incomplete}%
 For the first option (dot) the first expression
-shall be a glvalue having complete class type.
+shall be a glvalue having class type.
 For the second option (arrow) the first expression
-shall be a prvalue having pointer to complete class type.
+shall be a prvalue having pointer to class type.
+In both cases, the class type shall be complete
+unless the class member access appears in the definition of that class.
+\begin{note}
+If the class is incomplete, lookup in the complete class type
+is required to refer to the same declaration~(\ref{basic.scope.class}).
+\end{note}
 The expression \tcode{E1->E2} is
 converted to the equivalent form \tcode{(*(E1)).E2}; the remainder of
 \ref{expr.ref}~will address only the first option (dot).\footnote{Note that

source/overloading.tex

@@ -634,7 +634,7 @@
 with the set of non-template candidate functions.
 
 \pnum
-A defaulted move constructor or assignment operator~(\ref{class.copy}) that is
+A defaulted move special function~(\ref{class.copy}) that is
 defined as deleted is excluded from the set of candidate functions in all
 contexts.
 
@@ -1676,6 +1676,29 @@
 according to the partial ordering rules described in~\ref{temp.func.order},
 or, if not that,
 
+\item
+\tcode{F1} is a constructor for a class \tcode{D},
+\tcode{F2} is a constructor for a base class \tcode{B} of \tcode{D}, and
+for all arguments
+the corresponding parameters of \tcode{F1} and \tcode{F2} have the same type.
+\begin{example}
+\begin{codeblock}
+struct A {
+  A(int = 0);
+};
+
+struct B: A {
+  using A::A;
+  B();
+};
+
+int main() {
+  B b;  // OK, \tcode{B::B()}
+}
+\end{codeblock}
+\end{example}
+or, if not that,
+
 \item
 \tcode{F1} is generated from a
 \grammarterm{deduction-guide}~(\ref{over.match.class.deduct})

source/templates.tex

@@ -4889,13 +4889,18 @@
 
 \pnum
 If the explicit instantiation is for a class or member class, the
-\grammarterm{elaborated-type-specifier} in the \grammarterm{declaration} shall
-include a \grammarterm{simple-template-id}. If the explicit instantiation is for
+\grammarterm{elaborated-type-specifier} in the \grammarterm{declaration}
+shall include a \grammarterm{simple-template-id};
+otherwise, the \grammarterm{declaration}
+shall be a \grammarterm{simple-declaration} whose \grammarterm{init-declarator-list}
+comprises a single \grammarterm{init-declarator}
+that does not have an \grammarterm{initializer}.
+If the explicit instantiation is for
 a function or member function,
 the
 \grammarterm{unqualified-id}
 in the
-\grammarterm{declaration}
+\grammarterm{declarator}
 shall be either a
 \grammarterm{template-id}
 or, where all template arguments can be deduced, a
@@ -4915,9 +4920,9 @@
 the name of the class template specialization in the
 \grammarterm{qualified-id}
 for the member name shall be a \grammarterm{simple-template-id}.
-If the explicit instantiation is for a variable, the
-\grammarterm{unqualified-id} in the declaration shall be a
-\grammarterm{template-id}.
+If the explicit instantiation is for a variable template specialization,
+the \grammarterm{unqualified-id} in the \grammarterm{declarator}
+shall be a \grammarterm{simple-template-id}.
 An explicit instantiation shall appear in an enclosing namespace
 of its template. If the name declared in the explicit
 instantiation is an unqualified name, the explicit instantiation
@@ -4958,6 +4963,28 @@
 of the explicit instantiation names an implicitly-declared special member
 function (Clause~\ref{special}), the program is ill-formed.
 
+\pnum
+The \grammarterm{declaration} in an \grammarterm{explicit-instantiation} and the \grammarterm{declaration} produced by the corresponding substitution into the templated function, variable, or class are two declarations of the same entity.
+\begin{note}
+These declarations are required to have matching types as specified in~\ref{basic.link}, except as specified in~\ref{except.spec}.
+\begin{example}
+\begin{codeblock}
+template<typename T> T var = {};
+template float var<float>;   // OK, instantiated variable has type \tcode{float}
+template int var<int[16]>[]; // OK, absence of major array bound is permitted
+template int *var<int>;      // error: instantiated variable has type \tcode{int}
+
+template<typename T> auto av = T();
+template int av<int>;        // OK, variable with type \tcode{int} can be redeclared with type \tcode{auto}
+
+template<typename T> auto f() {}
+template void f<int>();      // error: function with deduced return type
+                             // redeclared with non-deduced return type~(\ref{dcl.spec.auto})
+\end{codeblock}
+\end{example}
+\end{note}
+Despite its syntactic form, the \grammarterm{declaration} in an \grammarterm{explicit-instantiation} for a variable is not itself a definition and does not conflict with the definition instantiated by an explicit instantiation definition for that variable.
+
 \pnum
 For a given set of template arguments, if an explicit
 instantiation of a template appears after a declaration of
@@ -5033,8 +5060,9 @@
 literal types,
 variables of reference types, and class template specializations,
 explicit instantiation declarations have the
-effect of suppressing the implicit instantiation of the entity to which they
-refer. \begin{note} The intent is that an inline function that is the
+effect of suppressing the implicit instantiation
+of the definition of the entity to which they refer.
+\begin{note} The intent is that an inline function that is the
 subject of an explicit instantiation declaration will still be implicitly
 instantiated when odr-used~(\ref{basic.def.odr}) so that the body can be considered for inlining, but
 that no out-of-line copy of the inline function would be generated in the