[Sema] Permit conversions to arrays of unknown bound

[Mordante]

Summary

This implements C++20's P0388.

[rsmith]

I made a start on this a while back and found a bunch more places that needed updates: https://github.com/zygoloid/llvm-project/commit/c23440979ac4f07ce38657ce0e69d010d2afa83e

Feel free to either take that patch as a basis or as inspiration for the remaining changes.

clang/lib/AST/ASTContext.cpp

QualType ASTContext::getUnqualifiedArrayType(QualType type,
   }
 
   const auto *DSAT = cast<DependentSizedArrayType>(AT);
   return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
                                     DSAT->getSizeModifier(), 0,
                                     SourceRange());
 }
 
+static bool canUnwrapSimilarArrayTypes(const ArrayType *AT1,
+                                       const ArrayType *AT2, bool CPlusPlus20) {
+  // If we don't have two array types with the same constant bound nor two
+  // incomplete array types, we've unwrapped everything we can.
+  // C++20 allows the combintion of constant bound and incomplete arrays.
+  if (const auto *CAT1 = dyn_cast<ConstantArrayType>(AT1))
+    if (const auto *CAT2 = dyn_cast<ConstantArrayType>(AT2))
+      return CAT1->getSize() == CAT2->getSize();
+
+  return CPlusPlus20 ||
+         (isa<IncompleteArrayType>(AT1) && isa<IncompleteArrayType>(AT2));
+}
+
 /// Attempt to unwrap two types that may both be array types with the same bound
 /// (or both be array types of unknown bound) for the purpose of comparing the
 /// cv-decomposition of two types per C++ [conv.qual].
 bool ASTContext::UnwrapSimilarArrayTypes(QualType &T1, QualType &T2) {
   bool UnwrappedAny = false;
   while (true) {
-    auto *AT1 = getAsArrayType(T1);
+    const auto *AT1 = getAsArrayType(T1);
     if (!AT1) return UnwrappedAny;
 
-    auto *AT2 = getAsArrayType(T2);
+    const auto *AT2 = getAsArrayType(T2);
     if (!AT2) return UnwrappedAny;
 
-    // If we don't have two array types with the same constant bound nor two
-    // incomplete array types, we've unwrapped everything we can.
-    if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
-      auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
-      if (!CAT2 || CAT1->getSize() != CAT2->getSize())
-        return UnwrappedAny;
-    } else if (!isa<IncompleteArrayType>(AT1) ||
-               !isa<IncompleteArrayType>(AT2)) {
-      return UnwrappedAny;
-    }
+    if (!canUnwrapSimilarArrayTypes(AT1, AT2, getLangOpts().CPlusPlus20))
 
     T1 = AT1->getElementType();
     T2 = AT2->getElementType();
     UnwrappedAny = true;
   }
 }
 
 /// Attempt to unwrap two types that may be similar (C++ [conv.qual]).

clang/lib/Sema/SemaOverload.cpp

TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
   // C++11 [over.ics.list]p1:
   //   When an argument is an initializer list, it is not an expression and
   //   special rules apply for converting it to a parameter type.
 
   ImplicitConversionSequence Result;
   Result.setBad(BadConversionSequence::no_conversion, From, ToType);
 
   // We need a complete type for what follows. Incomplete types can never be
-  // initialized from init lists.
-  if (!S.isCompleteType(From->getBeginLoc(), ToType))
+  // initialized from init lists. In C++20 an array of unknown bound can be
+  // initialized form a init list.
+  if (!S.isCompleteType(From->getBeginLoc(), ToType) &&
+      !S.getLangOpts().CPlusPlus20 && !isa<IncompleteArrayType>(ToType))
     return Result;
 
   // Per DR1467:
   //   If the parameter type is a class X and the initializer list has a single
   //   element of type cv U, where U is X or a class derived from X, the
   //   implicit conversion sequence is the one required to convert the element
   //   to the parameter type.
   //

clang/test/SemaCXX/const-cast.cpp

short *bad_const_cast_test(char const *volatile *const volatile *var)
   // Non-pointer.
   char v = const_cast<char>(**var2); // expected-error {{const_cast to 'char', which is not a reference, pointer-to-object, or pointer-to-data-member}}
   const int *ar[100] = {0};
   extern const int *aub[];
   // const_cast looks through arrays as of DR330.
   (void) const_cast<int *(*)[100]>(&ar); // ok
   (void) const_cast<int *(*)[]>(&aub); // ok
   // ... but the array bound must exactly match.
-  (void) const_cast<int *(*)[]>(&ar); // expected-error {{const_cast from 'const int *(*)[100]' to 'int *(*)[]' is not allowed}}
+  (void) const_cast<int *(*)[]>(&ar);
+#if __cplusplus < 202002L // P0388
+  // expected-error@-2 {{const_cast from 'const int *(*)[100]' to 'int *(*)[]' is not allowed}}
+#endif
   (void) const_cast<int *(*)[99]>(&ar); // expected-error {{const_cast from 'const int *(*)[100]' to 'int *(*)[99]' is not allowed}}
-  (void) const_cast<int *(*)[100]>(&aub); // expected-error {{const_cast from 'const int *(*)[]' to 'int *(*)[100]' is not allowed}}
+  (void) const_cast<int *(*)[100]>(&aub);
+#if __cplusplus < 202002L // P0388
+  // expected-error@-2 {{const_cast from 'const int *(*)[]' to 'int *(*)[100]' is not allowed}}
+#endif
   f fp1 = 0;
   // Function pointers.
   f fp2 = const_cast<f>(fp1); // expected-error {{const_cast to 'f' (aka 'int (*)(int)'), which is not a reference, pointer-to-object, or pointer-to-data-member}}
   void (A::*mfn)() = 0;
   (void)const_cast<void (A::*)()>(mfn); // expected-error-re {{const_cast to 'void (A::*)(){{( __attribute__\(\(thiscall\)\))?}}', which is not a reference, pointer-to-object, or pointer-to-data-member}}
   (void)const_cast<int&&>(0);
 #if __cplusplus < 201703L // N4261
   // expected-error@-2 {{const_cast from rvalue to reference type 'int &&'}}

clang/test/SemaCXX/overload-call.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify %s
 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++98 %s
 // RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++11 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++14 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++17 %s
+// RUN: %clang_cc1 -triple %itanium_abi_triple -pedantic -verify -std=c++20 %s
 
 int* f(int) { return 0; }
 float* f(float) { return 0; }
 void f();
 
 void test_f(int iv, float fv) {
   float* fp = f(fv);
   int* ip = f(iv);
void i() {
   h({1});
   h({1, 2});
   h({1, 2, 3});
   h({1, 2, 3, 4});
   h({1, 2, 3, 4, 5}); // expected-error {{no matching function for call to 'h'}}
 }
 
 } // namespace InitializerListToArray
+
+namespace P0338 {
+void f(int(&&)[]);
+void f(double(&&)[]);
+void f(int(&&)[2]);
+
+void g() {
+  f({1});
+#if __cplusplus < 202002L
+// expected-error@+3 {{type 'double' cannot be narrowed to 'int' in initializer list}}
+// expected-note@+2 {{insert an explicit cast to silence this issue}}
+#endif
+  f({1.0});
+#if __cplusplus < 202002L
+// expected-error@+3 2 {{type 'double' cannot be narrowed to 'int' in initializer list}}
+// expected-note@+2 2 {{insert an explicit cast to silence this issue}}
+#endif
+  f({1.0, 2.0});
+  f({1, 2});
+}
+} // namespace P0338
 #endif

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Class template argument deduction for alias templates</td>
       <td><a href="https://wg21.link/p1814r0">P1814R0</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Permit conversions to arrays of unknown bound</td>
       <td><a href="https://wg21.link/p0388r4">P0388R4</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 12</td>
     </tr>
     <tr>
       <td><tt>constinit</tt></td>
       <td><a href="https://wg21.link/p1143r2">P1143R2</a></td>
       <td class="full" align="center">Clang 10</td>
     </tr>
     <!-- Prague 2019 papers -->
     <tr>