Merge 2018-03 CWG Motion 6

Author: zygoloid

source/templates.tex

@@ -4015,35 +4015,17 @@
 \end{codeblock}
 \end{example}
 
-\pnum
-When a \grammarterm{qualified-id} is intended to refer to a type
-that is not a member of the current instantiation\iref{temp.dep.type}
-and its \grammarterm{nested-name-specifier}
-refers to a dependent type,
-it shall be
-prefixed by the keyword \tcode{typename}, forming a
-\grammarterm{typename-specifier}.
-If the \grammarterm{qualified-id} in a \grammarterm{typename-specifier}
-does not denote a type
-or a class template,
-the program is ill-formed.
-
 \begin{bnf}
 \nontermdef{typename-specifier}\br
   \terminal{typename} nested-name-specifier identifier\br
   \terminal{typename} nested-name-specifier \terminal{\opt{template}} simple-template-id
 \end{bnf}
 
 \pnum
-If a specialization of a template is instantiated for a set of
-\grammarterm{template-argument}{s}
-such that the
-\grammarterm{qualified-id}
-prefixed by
-\tcode{typename}
-does not denote a type
-or a class template,
-the specialization is ill-formed.
+A \grammarterm{typename-specifier}
+denotes the type or class template
+denoted by the \grammarterm{simple-type-specifier}\iref{dcl.type.simple}
+formed by omitting the keyword \tcode{typename}.
 The usual qualified name lookup\iref{basic.lookup.qual} is used to find the
 \grammarterm{qualified-id}
 even in the presence of
@@ -4088,20 +4070,76 @@
 \end{note}
 
 \pnum
-If, for a given set of template arguments, a specialization of a template is
-instantiated
-that refers to a \grammarterm{qualified-id}
-that denotes a type
-or a class template,
-and the
-\grammarterm{qualified-id} refers to a member of an unknown specialization,
-the \grammarterm{qualified-id} shall either be
-prefixed by \tcode{typename} or shall be used in a context in which it
-implicitly names a type as described above. \begin{example}
+A \grammarterm{qualified-id}
+is assumed to name a type if
+\begin{itemize}
+\item it is a qualified name in a type-id-only context (see below), or
+\item it is a \grammarterm{decl-specifier} of the \grammarterm{decl-specifier-seq} of a
+\begin{itemize}
+\item \grammarterm{simple-declaration} or a \grammarterm{function-definition} in namespace scope,
+\item \grammarterm{member-declaration},
+\item \grammarterm{parameter-declaration} in a \grammarterm{member-declaration}%
+\footnote{This includes friend function declarations.},
+unless that \grammarterm{parameter-declaration} appears in a default argument,
+\item \grammarterm{parameter-declaration} in a \grammarterm{declarator}
+of a function or function template declaration
+whose \grammarterm{declarator-id} is qualified,
+unless that \grammarterm{parameter-declaration}
+appears in a default argument,
+\item \grammarterm{parameter-declaration} in a \grammarterm{lambda-declarator},
+unless that \grammarterm{parameter-declaration} appears in a default argument, or
+\item \grammarterm{parameter-declaration} of a (non-type) \grammarterm{template-parameter}.
+\end{itemize}
+\end{itemize}
+A qualified name is said to be in a \defn{type-id-only context}
+if it appears in a
+\grammarterm{type-id},
+\grammarterm{new-type-id}, or
+\grammarterm{defining-type-id}
+and the smallest enclosing
+\grammarterm{type-id},
+\grammarterm{new-type-id}, or
+\grammarterm{defining-type-id}
+is a
+\grammarterm{new-type-id},
+\grammarterm{defining-type-id},
+\grammarterm{trailing-return-type},
+default argument of a \grammarterm{type-parameter} of a template, or
+\grammarterm{type-id} of a
+\tcode{static_cast},
+\tcode{const_cast},
+\tcode{reinterpret_cast}, or
+\tcode{dynamic_cast}.
+\begin{example}
+\begin{codeblock}
+template<class T> T::R f();             // OK, return type of a function declaration at global scope
+template<class T> void f(T::R);         // ill-formed (no diagnostic required), attempt to declare
+                                        // a \tcode{void} variable template
+template<class T> struct S {
+  using Ptr = PtrTraits<T>::Ptr;        // OK, in a \grammarterm{defining-type-id}
+  T::R f(T::P p) {                      // OK, class scope
+    return static_cast<T::R>(p);        // OK, \grammarterm{type-id} of a \tcode{static_cast}
+  }
+  auto g() -> S<T*>::Ptr;               // OK, \grammarterm{trailing-return-type}
+};
+template<typename T> void f() {
+  void (*pf)(T::X);                     // variable \tcode{pf} of type \tcode{void*} initialized with \tcode{T::X}
+  void g(T::X);                         // error: \tcode{T::X} at block scope does not denote a type
+                                        // (attempt to declare a \tcode{void} variable)
+}
+\end{codeblock}
+\end{example}
+
+\pnum
+A \grammarterm{qualified-id} that refers to a member of an unknown specialization,
+that is not prefixed by \tcode{typename},
+and that is not otherwise assumed to name a type (see above)
+denotes a non-type.
+\begin{example}
 
 \begin{codeblock}
 template <class T> void f(int i) {
-  T::x * i;         // \tcode{T::x} must not be a type
+  T::x * i;         // expression, not the declaration of a variable \tcode{i}
 }
 
 struct Foo {
@@ -4123,29 +4161,25 @@
 Within the definition of a class template or within the definition of a
 member of a class template following the \grammarterm{declarator-id}, the keyword
 \tcode{typename}
-is not required when referring to the name of a previously
-declared member of the class template that declares a type
-or a class template.
-\begin{note} Such names can be found using unqualified name lookup\iref{basic.lookup.unqual},
-class member lookup\iref{class.qual} into the current instantiation\iref{temp.dep.type},
-or class member access expression lookup\iref{basic.lookup.classref} when the
-type of the object expression is the current instantiation\iref{temp.dep.expr}.
-\end{note}
+is not required when referring to
+a member of the current instantiation\iref{temp.dep.type}.
 \begin{example}
-
 \begin{codeblock}
 template<class T> struct A {
   typedef int B;
-  B b;              // OK, no typename required
+  B b;              // OK, no \tcode{typename} required
 };
 \end{codeblock}
 \end{example}
 
 \pnum
 \indextext{checking!syntax}%
 \indextext{checking!point of error}%
+The validity of a template may be checked prior to any instantiation.
+\begin{note}
 Knowing which names are type names allows the syntax of every template
-to be checked.
+to be checked in this way.
+\end{note}
 The program is ill-formed, no diagnostic required, if:
 
 \begin{itemize}