CWG1223 Proposed resolution for CWG1223

[dcl.ambig.res] Use "is to be considered a" instead of "is"
to avoid redefining the grammar production /type-id/.
[stmt.ambig] Likewise, don't \grammarterm "declaration"
in "is a declaration" to avoid redefining /declaration/.
[stmt.ambig] Reword comment in example for consistency.

Author: burblebee

source/declarations.tex

@@ -2371,6 +2371,11 @@
 such as the potential parameter declaration,
 that could possibly be a declaration
 to be a declaration.
+However, a construct that can syntactically be a \grammarterm{declaration}
+whose outermost \grammarterm{declarator}
+would match the grammar of a \grammarterm{declarator}
+with a \grammarterm{trailing-return-type}
+is a declaration only if it starts with \keyword{auto}.
 \begin{note}
 A declaration can be explicitly disambiguated by adding parentheses
 around the argument.
@@ -2382,13 +2387,16 @@
 struct S {
   S(int);
 };
+typedef struct BB { int C[2]; } *B, C;
 
 void foo(double a) {
   S w(int(a));                  // function declaration
   S x(int());                   // function declaration
   S y((int(a)));                // object declaration
   S y((int)a);                  // object declaration
   S z = int(a);                 // object declaration
+  S a(B()->C);                  // object declaration
+  S b(auto()->C);               // function declaration
 }
 \end{codeblock}
 \end{example}
@@ -2401,6 +2409,11 @@
 \grammarterm{type-id}
 in its syntactic context shall be considered a
 \grammarterm{type-id}.
+However, a construct that can syntactically be a \grammarterm{type-id}
+whose outermost \grammarterm{abstract-declarator}
+would match the grammar of an \grammarterm{abstract-declarator}
+with a \grammarterm{trailing-return-type}
+is to be considered a \grammarterm{type-id} only if it starts with \keyword{auto}.
 \begin{example}
 \begin{codeblock}
 template <class T> struct X {};
@@ -2419,6 +2432,12 @@
   (int(a))+1;                   // expression
   (int(unsigned(a)))+1;         // type-id (ill-formed)
 }
+
+typedef struct BB { int C[2]; } *B, C;
+void g() {
+  sizeof(B()->C[1]);            // OK, \tcode{sizeof(}expression\tcode{)}
+  sizeof(auto()->C[1]);         // error: \tcode{sizeof} of a function returning an array
+}
 \end{codeblock}
 \end{example}
 

source/statements.tex

@@ -1081,7 +1081,9 @@
 conversion\iref{expr.type.conv} as its leftmost subexpression can be
 indistinguishable from a \grammarterm{declaration} where the first
 \grammarterm{declarator} starts with a \tcode{(}. In those cases the
-\grammarterm{statement} is a \grammarterm{declaration}.
+% FIXME: Shouldn't "\grammarterm{declaration}" be "declaration" here?
+\grammarterm{statement} is a \grammarterm{declaration},
+except as specified below.
 
 \pnum
 \begin{note}
@@ -1163,4 +1165,35 @@
 }
 \end{codeblock}
 \end{example}
+
+\pnum
+A syntactically ambiguous statement that can syntactically be
+a \grammarterm{declaration} with an outermost \grammarterm{declarator}
+with a \grammarterm{trailing-return-type}
+is a declaration only if it starts with \keyword{auto}.
+\begin{example}
+\begin{codeblock}
+struct M;
+struct S {
+  S* operator()();
+  int N;
+  int M;
+
+  void mem(S s) {
+    auto(s)()->M;               // expression, \tcode{S::M} hides \tcode{::M}
+  }
+};
+
+void f(S s) {
+  {
+    auto(s)()->N;               // expression
+    auto(s)()->M;               // function declaration
+  }
+  {
+    S(s)()->N;                  // expression
+    S(s)()->M;                  // expression
+  }
+}
+\end{codeblock}
+\end{example}
 \indextext{statement|)}