[clang] Implement CWG 2397

[zyounan]

Summary

This patch implements CWG 2397, allowing array of placeholder type
to be valid.

See also https://wg21.cmeerw.net/cwg/issue2397.

[zyounan]

Note GCC had implemented such feature since GCC 12.

[shafik]

This looks good but I will let at least one more reviewer take a look

[aaron.ballman]

The changes need a release note, but also this should have changes to clang/test/CXX/drs/dr23xx.cpp with the proper dr markings and update clang/www/cxx_dr_status.html.

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/cwg2397.cpp

12

I think it'd be good to also show a constexpr test, like:

constexpr int foo() {
  int a[] = { 1, 2, 3 };
  auto (&c)[3] = a;

  return c[2];
}

static_assert(foo() == 3, "");

to prove that we actually perform the assignment properly, not just figure out the deduced type correctly.

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1-cxx0x.cpp

5–6

I've seen worse diagnostics, but the phrasing here is interesting -- if you use int a[5] = b; instead of auto, you get array initializer must be an initializer list as a diagnostic, so I wonder why we're getting such a drastically different diagnostic for auto. Same for the diagnostic below.

[Endill]

Agree, this test clearly belongs to clang/test/CXX/drs/dr23xx.cpp.
There is a clang/www/make_cxx_dr_status script to update cxx_dr_status page, so you don't have to edit it manually.

[zyounan]

Address comments

[zyounan]

Thank you for the suggestion and I've updated my patch. :)

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/cwg2397.cpp

12

Indeed. I will enable it only with C++14 or later. (I didn't come up a way to get around the restriction for C++11, though.)

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1-cxx0x.cpp

5–6

You're right that such diagnostic looks a bit strange but FYI, GCC now emits diagnostic like so:

auto a[5] = b; // error: unable to deduce 'auto [5]' from 'b'
int c[5] = b;  // error: array must be initialized with a brace-enclosed initializer

I agree that what we expect here is to emit messages just like int a[5] = b; would produce with respect to better understandability, however, the err_auto_var_deduction_failure error is actually emitted due to type deduction failure, whereas err_array_init_not_init_list would be produced later by initialization error IIUC. So, IMHO such message makes sence as per what standard says, that for each type P, after being substituted with deduced A, shall be compatible with type A. temp.deduct.type/1

// Feel free to correct me if I'm wrong :)

[aaron.ballman]

LGTM!

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1-cxx0x.cpp

5–6

Ah, good catch! Okay, this seems reasonable to me now that I understand it better, thank you.

clang/docs/ReleaseNotes.rst

 
 - Implemented `P2036R3: Change scope of lambda trailing-return-type <https://wg21.link/P2036R3>`_
   and `P2579R0 Mitigation strategies for P2036 <https://wg21.link/P2579R0>`_.
   These proposals modify how variables captured in lambdas can appear in trailing return type
   expressions and how their types are deduced therein, in all C++ language versions.
 
 Resolutions to C++ Defect Reports
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Implemented `DR2397 <https://wg21.link/CWG2397>`_ which allows ``auto`` specifier for pointers
+  and reference to arrays.
 
 C Language Changes
 ------------------
 - Support for outputs from asm goto statements along indirect edges has been
   added. (`#53562 <https://github.com/llvm/llvm-project/issues/53562>`_)
 
 C2x Feature Support
 ^^^^^^^^^^^^^^^^^^^

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx98_compat_auto_type_specifier : Warning<
   "'auto' type specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_auto_variable_cannot_appear_in_own_initializer : Error<
   "variable %0 declared with deduced type %1 "
   "cannot appear in its own initializer">;
 def err_binding_cannot_appear_in_own_initializer : Error<
   "binding %0 cannot appear in the initializer of its own "
   "decomposition declaration">;
-def err_illegal_decl_array_of_auto : Error<
-  "'%0' declared as array of %1">;
 def err_new_array_of_auto : Error<
   "cannot allocate array of 'auto'">;
 def err_auto_not_allowed : Error<
   "%select{'auto'|'decltype(auto)'|'__auto_type'|"
   "use of "
   "%select{class template|function template|variable template|alias template|"
   "template template parameter|concept|template}2 %3 requires template "
   "arguments; argument deduction}0 not allowed "

clang/lib/Sema/SemaType.cpp

case DeclaratorChunk::Array: {
           S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) <<
             (ASM == ArrayType::Static ? "'static'" : "type qualifier");
           if (ASM == ArrayType::Static)
             ASM = ArrayType::Normal;
           ATI.TypeQuals = 0;
           D.setInvalidType(true);
         }
       }
-      const AutoType *AT = T->getContainedAutoType();
-      // Allow arrays of auto if we are a generic lambda parameter.
-      // i.e. [](auto (&array)[5]) { return array[0]; }; OK
-      if (AT && D.getContext() != DeclaratorContext::LambdaExprParameter) {
-        // We've already diagnosed this for decltype(auto).
-        if (!AT->isDecltypeAuto())
-          S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto)
-              << getPrintableNameForEntity(Name) << T;
-        T = QualType();
-        break;
-      }
 
       // Array parameters can be marked nullable as well, although it's not
       // necessary if they're marked 'static'.
       if (complainAboutMissingNullability == CAMN_Yes &&
           !hasNullabilityAttr(DeclType.getAttrs()) &&
           ASM != ArrayType::Static &&
           D.isPrototypeContext() &&
           !hasOuterPointerLikeChunk(D, chunkIndex)) {

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/cwg2397.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14
+
+void f() {
+  int a[5];
+  auto (*b)[5] = &a;
+  auto (&c)[5] = a;
+  auto (&&d)[5] = static_cast<int(&&)[5]>(a);
+  auto e[] = {0}; // expected-error{{cannot deduce actual type for variable 'e' with type 'auto[]' from initializer list}}
+  static_assert(__is_same(decltype(b), int (*)[5]), "");
+  static_assert(__is_same(decltype(c), int (&)[5]), "");
+  static_assert(__is_same(decltype(d), int (&&)[5]), "");
+}
+
+#if __cplusplus >= 201402L
+
+constexpr int g() {
+  int a[] = {1, 2, 3};
+  auto (&b)[3] = a;
+  return b[1];
+}
+
+static_assert(g() == 2, "");
+
+#endif

clang/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1-cxx0x.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
 
 void f() {
   int b[5];
-  auto a[5] = b; // expected-error{{'a' declared as array of 'auto'}}
-  auto *c[5] = b; // expected-error{{'c' declared as array of 'auto *'}}
+  auto a[5] = b; // expected-error{{variable 'a' with type 'auto[5]' has incompatible initializer of type 'int[5]'}}
+  auto *c[5] = b; // expected-error{{variable 'c' with type 'auto *[5]' has incompatible initializer of type 'int[5]'}}
 }

clang/test/CXX/drs/dr23xx.cpp

namespace dr2396 { // dr2396: no
   // FIXME: per P1787 "Calling a conversion function" example, all of the
   // examples below are well-formed, with B resolving to A::B, but currently
   // it's been resolved to dr2396::B. 
 
   // void f(A a) { a.operator B B::*(); }            
   // void g(A a) { a.operator decltype(B()) B::*(); }
   // void g2(A a) { a.operator B decltype(B())::*(); }
 }
+
+#if __cplusplus >= 201103L
+namespace dr2397 { // dr2397: 17
+  void foo() {
+    int a[5];
+
+    auto (&b)[5] = a;
+    auto (*c)[5] = &a;
+  }
+} // namespace dr2397
+#endif

clang/www/cxx_dr_status.html

<tr id="2396">
     <td>CD6</td>
     <td>Lookup of names in complex <I>conversion-type-id</I>s</td>
     <td class="none" align="center">No</td>
   </tr>
   <tr id="2397">
     <td><a href="https://wg21.link/cwg2397">2397</a></td>
     <td>CD6</td>
     <td><TT>auto</TT> specifier for pointers and references to arrays</td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 17</td>
   </tr>
   <tr class="open" id="2398">
     <td><a href="https://wg21.link/cwg2398">2398</a></td>
     <td>drafting</td>
     <td>Template template parameter matching and deduction</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2399">