Merge 2018-11 CWG Motion 5

P1131R2 Core Issue 2292: simple-template-id is ambiguous between class-name and type-name

Fixes #2398

Author: zygoloid

source/basic.tex

@@ -1776,19 +1776,13 @@
 of that enumeration.
 
 \pnum
-If a \grammarterm{pseudo-destructor-name}\iref{expr.pseudo} contains a
-\grammarterm{nested-name-specifier}, the \grammarterm{type-name}{s} are looked
-up as types in the scope designated by the
-\grammarterm{nested-name-specifier}. Similarly, in a
-\grammarterm{qualified-id} of the form:
+In a \grammarterm{qualified-id} of the form:
 
 \begin{ncbnf}
-\opt{nested-name-specifier} class-name \terminal{::} \terminal{\~} class-name
+\opt{nested-name-specifier} type-name \terminal{::} \terminal{\~} type-name
 \end{ncbnf}
-
-the second \grammarterm{class-name} is looked up in the same scope as the
-first. \begin{example}
-
+the second \grammarterm{type-name} is looked up in the same scope as the first.
+\begin{example}
 \begin{codeblock}
 struct C {
   typedef int I;
@@ -1808,8 +1802,10 @@
   p->AB::~AB();     // explicitly calls the destructor for \tcode{A}
 }
 \end{codeblock}
-\end{example} \begin{note} \ref{basic.lookup.classref} describes how name
-lookup proceeds after the \tcode{.} and \tcode{->} operators. \end{note}
+\end{example}
+\begin{note} \ref{basic.lookup.classref} describes how name
+lookup proceeds after the \tcode{.} and \tcode{->} operators.
+\end{note}
 
 \rSec3[class.qual]{Class members}
 
@@ -2222,9 +2218,6 @@
 access\iref{expr.ref} is an \grammarterm{unqualified-id}, and the type of
 the object expression is of a class type \tcode{C}, the
 \grammarterm{unqualified-id} is looked up in the scope of class \tcode{C}.
-For a pseudo-destructor call\iref{expr.pseudo},
-the \grammarterm{unqualified-id} is looked up in the context of the complete
-\grammarterm{postfix-expression}.
 
 \pnum
 If the \grammarterm{unqualified-id} is \tcode{\~}\grammarterm{type-name}, the

source/classes.tex

@@ -422,12 +422,8 @@
 
 \pnum
 \indextext{class name!\idxcode{typedef}}%
-A \grammarterm{typedef-name}\iref{dcl.typedef} that names a class type,
-or a cv-qualified version thereof, is also a \grammarterm{class-name}. If a
-\grammarterm{typedef-name} that names a cv-qualified class type is used
-where a \grammarterm{class-name} is required, the cv-qualifiers are
-ignored. A \grammarterm{typedef-name} shall not be used as the
-\grammarterm{identifier} in a \grammarterm{class-head}.
+A \grammarterm{simple-template-id} is only a \grammarterm{class-name}
+if its \grammarterm{template-name} names a class template.
 
 \rSec1[class.mem]{Class members}%
 \indextext{declaration!member}%
@@ -1233,8 +1229,7 @@
 constructor\iref{class.qual}.
 \end{itemize}
 
-The \grammarterm{class-name} shall not be a \grammarterm{typedef-name}. In a constructor
-declaration, each \grammarterm{decl-specifier} in the optional
+In a constructor declaration, each \grammarterm{decl-specifier} in the optional
 \grammarterm{decl-specifier-seq} shall be \tcode{friend}, \tcode{inline},
 \tcode{constexpr}, or an \grammarterm{explicit-specifier}.
 \begin{example}
@@ -2119,8 +2114,7 @@
 same class as the \grammarterm{nested-name-specifier}.
 \end{itemize}
 
-The \grammarterm{class-name} shall not be a \grammarterm{typedef-name}. A
-destructor shall take no arguments\iref{dcl.fct}.
+A destructor shall take no arguments\iref{dcl.fct}.
 Each \grammarterm{decl-specifier} of the \grammarterm{decl-specifier-seq}
 of a destructor declaration (if any) shall be \tcode{friend}, \tcode{inline}, or
 \tcode{virtual}.
@@ -2390,7 +2384,7 @@
 \begin{note}
 \indextext{fundamental type!destructor and}%
 The notation for explicit call of a destructor can be used for any scalar type
-name\iref{expr.pseudo}.
+name\iref{expr.prim.id.dtor}.
 Allowing this makes it possible to write code without having to know if a
 destructor exists for a given type.
 For example:
@@ -3421,7 +3415,7 @@
 
 \begin{bnf}
 \nontermdef{class-or-decltype}\br
-    \opt{nested-name-specifier} class-name\br
+    \opt{nested-name-specifier} type-name\br
     nested-name-specifier \terminal{template} simple-template-id\br
     decltype-specifier
 \end{bnf}
@@ -3440,17 +3434,18 @@
 \pnum
 \indextext{type!incomplete}%
 A \grammarterm{class-or-decltype} shall denote
-a class type that is not
-an incompletely defined class\iref{class}.
+a (possibly cv-qualified) class type that is not
+an incompletely defined class\iref{class.mem};
+any cv-qualifiers are ignored.
 The class denoted by the \grammarterm{class-or-decltype} of
 a \grammarterm{base-specifier} is called a
 \defnadj{direct}{base class}
 for the class being defined.
 \indextext{base class}%
 \indextext{derivation|see{inheritance}}%
 During the lookup for a base class name, non-type names are
-ignored\iref{basic.scope.hiding}. If the name found is not a
-\grammarterm{class-name}, the program is ill-formed. A class \tcode{B} is a
+ignored\iref{basic.scope.hiding}.
+A class \tcode{B} is a
 base class of a class \tcode{D} if it is a direct base class of
 \tcode{D} or a direct base class of one of \tcode{D}'s base classes.
 A class is an \defnadj{indirect}{base class} of another if it is a base

source/declarations.tex

@@ -550,20 +550,21 @@
 
 \begin{bnf}
 \nontermdef{typedef-name}\br
-    identifier
+    identifier\br
+    simple-template-id
 \end{bnf}
 
 A name declared with the \tcode{typedef} specifier becomes a
-\grammarterm{typedef-name}. Within the scope of its declaration, a
-\grammarterm{typedef-name} is syntactically equivalent to a keyword and
-names the type associated with the identifier in the way described in
-\ref{dcl.decl}.
+\grammarterm{typedef-name}.
+A \grammarterm{typedef-name} names
+the type associated with the \grammarterm{identifier}\iref{dcl.decl}
+or \grammarterm{simple-template-id}\iref{temp};
 \indextext{declaration!typedef@\tcode{typedef} as type}%
 \indextext{equivalence!type}%
 \indextext{synonym!type name as}%
-A \grammarterm{typedef-name} is thus a synonym for another type. A
+a \grammarterm{typedef-name} is thus a synonym for another type. A
 \grammarterm{typedef-name} does not introduce a new type the way a class
-declaration\iref{class.name} or enum declaration does.
+declaration\iref{class.name} or enum declaration\iref{dcl.enum} does.
 \begin{example}
 After
 
@@ -677,18 +678,20 @@
 \end{example}
 
 \pnum
-\begin{note}
 \indextext{class name!\idxcode{typedef}}%
-A \grammarterm{typedef-name} that names a class type, or a cv-qualified
-version thereof, is also a \grammarterm{class-name}\iref{class.name}. If
-a \grammarterm{typedef-name} is used to identify the subject of an
+A \grammarterm{simple-template-id} is only a \grammarterm{typedef-name}
+if its \grammarterm{template-name} names
+an alias template or a template \grammarterm{template-parameter}.
+\begin{note}
+A \grammarterm{simple-template-id} that names a class template specialization
+is a \grammarterm{class-name}\iref{class.name}.
+If a \grammarterm{typedef-name} is used to identify the subject of an
 \grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a class
 definition\iref{class}, a constructor
 declaration\iref{class.ctor}, or a destructor
 declaration\iref{class.dtor}, the program is ill-formed.
 \end{note}
 \begin{example}
-
 \begin{codeblock}
 struct S {
   S();
@@ -1270,7 +1273,6 @@
     class-name\br
     enum-name\br
     typedef-name\br
-    simple-template-id
 \end{bnf}
 
 \begin{bnf}
@@ -1516,17 +1518,19 @@
 the class whenever it is named.
 
 \pnum
+\begin{note}
 \ref{basic.lookup.elab} describes how name lookup proceeds for the
-\grammarterm{identifier} in an \grammarterm{elaborated-type-specifier}. If the
-\grammarterm{identifier} resolves to a \grammarterm{class-name} or
+\grammarterm{identifier} in an \grammarterm{elaborated-type-specifier}.
+\end{note}
+If the \grammarterm{identifier} or \grammarterm{simple-template-id}
+resolves to a \grammarterm{class-name} or
 \grammarterm{enum-name}, the \grammarterm{elaborated-type-specifier}
 introduces it into the declaration the same way a
-\grammarterm{simple-type-specifier} introduces its \grammarterm{type-name}. If
-the \grammarterm{identifier} resolves to a
-\grammarterm{typedef-name} or the \grammarterm{simple-template-id} resolves to
-an alias template specialization,
-the
-\grammarterm{elaborated-type-specifier} is ill-formed.
+\grammarterm{simple-type-specifier} introduces
+its \grammarterm{type-name}\iref{dcl.type.simple}.
+If the \grammarterm{identifier} or \grammarterm{simple-template-id} resolves to a
+\grammarterm{typedef-name} (\ref{dcl.typedef}, \ref{temp.names}),
+the \grammarterm{elaborated-type-specifier} is ill-formed.
 \begin{note}
 This implies that, within a class template with a template
 \grammarterm{type-parameter} \tcode{T}, the declaration