Fix aggregate CTAD with string literals adding extra const

[MitalAshok]

Summary

Missing a withConst, so when deducing from a string literal, a const is erroneously added to the deduced type.

[MitalAshok]

clang/lib/Sema/SemaInit.cpp

10707

The "const-qualified" here was missing

[ychen]

Thanks for catching this. The change LGTM. I think this is https://wg21.link/cwg2681. Could you please move the test to clang/test/CXX/drs/dr26xx.cpp and keep only these tests that are in the DR? Then you could run clang/www/make_cxx_dr_status to update clang/www/cxx_dr_status.html.

[ychen]

clang/test/SemaTemplate/aggregate-deduction-candidate.cpp seems need updates.

[MitalAshok]

Add status for CWG2681 and fixed aggregate-deduction-candidate test

[ychen]

LGTM. Thank you!

clang/lib/Sema/SemaInit.cpp

auto SynthesizeAggrGuide = [&](InitListExpr *ListInit) {
 
       InitListChecker CheckInitList(*this, Entity, ListInit, Ty, ElementTypes);
       if (!CheckInitList.HadError()) {
         // C++ [over.match.class.deduct]p1.8:
         //   if e_i is of array type and x_i is a braced-init-list, T_i is an
         //   rvalue reference to the declared type of e_i and
         // C++ [over.match.class.deduct]p1.9:
         //   if e_i is of array type and x_i is a bstring-literal, T_i is an
         //   lvalue reference to the const-qualified declared type of e_i and
         // C++ [over.match.class.deduct]p1.10:
         //   otherwise, T_i is the declared type of e_i
         for (int I = 0, E = ListInit->getNumInits();
              I < E && !isa<PackExpansionType>(ElementTypes[I]); ++I)
           if (ElementTypes[I]->isArrayType()) {
             if (isa<InitListExpr>(ListInit->getInit(I)))
               ElementTypes[I] = Context.getRValueReferenceType(ElementTypes[I]);
             else if (isa<StringLiteral>(
                          ListInit->getInit(I)->IgnoreParenImpCasts()))
-              ElementTypes[I] = Context.getLValueReferenceType(ElementTypes[I]);
+              ElementTypes[I] =
+                  Context.getLValueReferenceType(ElementTypes[I].withConst());
           }
 
         llvm::FoldingSetNodeID ID;
         ID.AddPointer(Template);
         for (auto &T : ElementTypes)
           T.getCanonicalType().Profile(ID);
         unsigned Hash = ID.ComputeHash();
         if (AggregateDeductionCandidates.count(Hash) == 0) {

clang/test/CXX/drs/dr26xx.cpp

 void f() {
     int neck, tail;
     volatile int brachiosaur;
     brachiosaur += neck;                // OK
     brachiosaur -= neck;                // OK
     brachiosaur |= neck;                // OK
 }
 }
+
+namespace dr2681 { // dr2681: 17
+using size_t = decltype(sizeof(int));
+
+template<class T, size_t N>
+struct H {
+  T array[N];
+};
+template<class T, size_t N>
+struct I {
+  volatile T array[N];
+};
+template<size_t N>
+struct J {  // expected-note 3{{candidate}}
+  unsigned char array[N];
+};
+
+H h = { "abc" };
+I i = { "def" };
+static_assert(__is_same(decltype(h), H<char, 4>));  // Not H<const char, 4>
+static_assert(__is_same(decltype(i), I<char, 4>));
+
+J j = { "ghi" };  // expected-error {{no viable constructor or deduction guide}}
+}

clang/test/SemaTemplate/aggregate-deduction-candidate.cpp

namespace Array {
   // CHECK:     |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0
   // CHECK:     | `-TemplateTypeParm {{.*}} 'T'
   // CHECK:     `-DeclRefExpr {{.*}} 'size_t':'unsigned {{.*}}' NonTypeTemplateParm {{.*}} 'N' 'size_t':'unsigned {{.*}}'
 
   // CHECK: Dumping Array::<deduction guide for A>:
   // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for A>
   // CHECK: |-TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T
   // CHECK: |-NonTypeTemplateParmDecl {{.*}} 'size_t':'unsigned {{.*}}' depth 0 index 1 N
-  // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (T (&)[N]) -> A<T, N>'
-  // CHECK: | `-ParmVarDecl {{.*}} 'T (&)[N]'
-  // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (const char (&)[5]) -> Array::A<const char, 5>'
-  // CHECK:   |-TemplateArgument type 'const char'
-  // CHECK:   | `-QualType {{.*}} 'const char' const
-  // CHECK:   |   `-BuiltinType {{.*}} 'char'
+  // CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for A> 'auto (const T (&)[N]) -> A<T, N>'
+  // CHECK: | `-ParmVarDecl {{.*}} 'const T (&)[N]'
+  // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for A> 'auto (const char (&)[5]) -> Array::A<char, 5>'
+  // CHECK:   |-TemplateArgument type 'char'
+  // CHECK:   | `-BuiltinType {{.*}} 'char'
   // CHECK:   |-TemplateArgument integral 5
   // CHECK:   `-ParmVarDecl {{.*}} 'const char (&)[5]'
-  // CHECK: FunctionProtoType {{.*}} 'auto (T (&)[N]) -> A<T, N>' dependent trailing_return cdecl
+  // CHECK: FunctionProtoType {{.*}} 'auto (const T (&)[N]) -> A<T, N>' dependent trailing_return cdecl
   // CHECK: |-InjectedClassNameType {{.*}} 'A<T, N>' dependent
   // CHECK: | `-CXXRecord {{.*}} 'A'
-  // CHECK: `-LValueReferenceType {{.*}} 'T (&)[N]' dependent
-  // CHECK:   `-DependentSizedArrayType {{.*}} 'T[N]' dependent
-  // CHECK:     |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0
-  // CHECK:     | `-TemplateTypeParm {{.*}} 'T'
-  // CHECK:     `-DeclRefExpr {{.*}} 'size_t':'unsigned {{.*}}' NonTypeTemplateParm {{.*}} 'N' 'size_t':'unsigned {{.*}}'
+  // CHECK: `-LValueReferenceType {{.*}} 'const T (&)[N]' dependent
+  // CHECK:   `-QualType {{.*}} 'const T[N]' const
+  // CHECK:     `-DependentSizedArrayType {{.*}} 'T[N]' dependent
+  // CHECK:       |-TemplateTypeParmType {{.*}} 'T' dependent depth 0 index 0
+  // CHECK:       | `-TemplateTypeParm {{.*}} 'T'
+  // CHECK:       `-DeclRefExpr {{.*}} 'size_t':'unsigned{{.*}}' NonTypeTemplateParm {{.*}} 'N' 'size_t':'unsigned{{.*}}'
 }
 
 namespace BraceElision {
   template <typename T> struct A { // cxx17-note 4 {{candidate}}
     T array[2];
   };
 
   A a1 = {0, 1}; // cxx17-error {{no viable}}

clang/www/cxx_dr_status.html

<tr class="open" id="2680">
     <td>open</td>
     <td>Class template argument deduction for aggregates with designated initializers</td>
     <td align="center">Not resolved</td>
   </tr>
   <tr id="2681">
     <td><a href="https://cplusplus.github.io/CWG/issues/2681.html">2681</a></td>
     <td>DR</td>
     <td>Deducing member array type from string literal</td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 17</td>
   </tr>
   <tr id="2682">
     <td><a href="https://cplusplus.github.io/CWG/issues/2682.html">2682</a></td>
     <td>DR</td>
     <td>Templated function vs. function template</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2683">