[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

11

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

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

11

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

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

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

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
+
+void foo() {
+  int a[5];
+
+  auto (&b)[5] = a;
+  auto (*c)[5] = &a;
+
+  auto d[] = {0}; // expected-error{{cannot deduce actual type for variable 'd' with type 'auto[]' from initializer list}}
+}
+
+void g() {
+  int a[5];
+  auto (*b)[5] = &a;
+  auto (&c)[5] = a;
+  auto (&&d)[5] = static_cast<int(&&)[5]>(a);
+  static_assert(__is_same(decltype(b), int (*)[5]), "");
+  static_assert(__is_same(decltype(c), int (&)[5]), "");
+  static_assert(__is_same(decltype(d), int (&&)[5]), "");
+}

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]'}}
 }