[clang][clangd] Desugar array type.

[lh123]

Summary

Desugar array type.

[sammccall]

Nice!

clang/lib/AST/ASTDiagnostic.cpp

134

this doesn't directly express the idea "we handle all array types". You *could* write:

if (const auto *AT = dyn_cast<ArrayType>(Ty)) {
 QualType ElementTy = desugar(...);
 switch(AT->getTypeClass()) {
    case Type::ConstantArray:
      QT = Context.getConstantArrayType(...);
      break;
    ...
    default:
      llvm_unreachable("Unhandled array type");
 }
 break;
}

Up to you whether you think this is clearer.

clang-tools-extra/clangd/unittests/HoverTests.cpp

class Foo {})cpp";
        R"cpp(
           using m_int = int;
 
           template <int Size> m_int ^[[arr]][Size];
          )cpp",
        [](HoverInfo &HI) {
          HI.Name = "arr";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "m_int[Size]";
+         HI.Type = {"m_int[Size]", "int[Size]"};
          HI.NamespaceScope = "";
          HI.Definition = "template <int Size> m_int arr[Size]";
          HI.TemplateParameters = {{{"int"}, {"Size"}, llvm::None}};
        }},
       {// Var template decl specialization
        R"cpp(
           using m_int = int;
 
           template <int Size> m_int arr[Size];
 
           template <> m_int ^[[arr]]<4>[4];
          )cpp",
        [](HoverInfo &HI) {
          HI.Name = "arr<4>";
          HI.Kind = index::SymbolKind::Variable;
-         HI.Type = "m_int[4]";
+         HI.Type = {"m_int[4]", "int[4]"};
          HI.NamespaceScope = "";
          HI.Definition = "m_int arr[4]";
        }},
       {// Canonical type
        R"cpp(
           template<typename T>
           struct TestHover {
             using Type = T;
class Foo {})cpp";
        [](HoverInfo &HI) {
          HI.Name = "AA";
          HI.NamespaceScope = "";
          HI.LocalScope = "";
          HI.Kind = index::SymbolKind::TypeAlias;
          HI.Definition = "template <typename T> using AA = A<T>";
          HI.Type = {"A<T>", "type-parameter-0-0"}; // FIXME: should be 'T'
          HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
+       }},
+      {// Constant array
+       R"cpp(
+          using m_int = int;
+
+          m_int ^[[arr]][10];
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "arr";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "";
+         HI.Kind = index::SymbolKind::Variable;
+         HI.Definition = "m_int arr[10]";
+         HI.Type = {"m_int[10]", "int[10]"};
+       }},
+      {// Incomplete array
+       R"cpp(
+          using m_int = int;
+
+          extern m_int ^[[arr]][];
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "arr";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "";
+         HI.Kind = index::SymbolKind::Variable;
+         HI.Definition = "extern m_int arr[]";
+         HI.Type = {"m_int[]", "int[]"};
+       }},
+      {// Dependent size array
+       R"cpp(
+          using m_int = int;
+
+          template<int Size>
+          struct Test {
+            m_int ^[[arr]][Size];
+          };
+         )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "arr";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "Test<Size>::";
+         HI.AccessSpecifier = "public";
+         HI.Kind = index::SymbolKind::Field;
+         HI.Definition = "m_int arr[Size]";
+         HI.Type = {"m_int[Size]", "int[Size]"};
        }}};
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a

clang/lib/AST/ASTDiagnostic.cpp

if (const TemplateSpecializationType *TST =
           ShouldAKA = true;
           QT = Context.getTemplateSpecializationType(
               TST->getTemplateName(), Args, QT);
         }
         break;
       }
     }
 
+    if (const auto *AT = dyn_cast<ArrayType>(Ty)) {
+      QualType ElementTy =
+          desugarForDiagnostic(Context, AT->getElementType(), ShouldAKA);
+      if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
+        QT = Context.getConstantArrayType(
+            ElementTy, CAT->getSize(), CAT->getSizeExpr(),
+            CAT->getSizeModifier(), CAT->getIndexTypeCVRQualifiers());
+      else if (const auto *VAT = dyn_cast<VariableArrayType>(AT))
+        QT = Context.getVariableArrayType(
+            ElementTy, VAT->getSizeExpr(), VAT->getSizeModifier(),
+            VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
+      else if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(AT))
+        QT = Context.getDependentSizedArrayType(
+            ElementTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
+            DSAT->getIndexTypeCVRQualifiers(), DSAT->getBracketsRange());
+      else if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT))
+        QT = Context.getIncompleteArrayType(ElementTy, IAT->getSizeModifier(),
+                                            IAT->getIndexTypeCVRQualifiers());
+      else
+        llvm_unreachable("Unhandled array type");
+      break;
+    }
+
     // Don't desugar magic Objective-C types.
     if (QualType(Ty,0) == Context.getObjCIdType() ||
         QualType(Ty,0) == Context.getObjCClassType() ||
         QualType(Ty,0) == Context.getObjCSelType() ||
         QualType(Ty,0) == Context.getObjCProtoType())
       break;
 
     // Don't desugar va_list.

clang/test/Misc/diag-aka-types.cpp

 using B = A<decltype(1+2)>;
 int a5 = B(); // expected-error{{no viable conversion from 'B' (aka 'A<int>') to 'int'}}
 
 decltype(void()) (&f1)() = 0; // expected-error{{non-const lvalue reference to type 'decltype(void()) ()' (aka 'void ()') cannot bind to a temporary of type 'int'}}
 decltype(void()) (&f2)(int) = 0; // expected-error{{non-const lvalue reference to type 'decltype(void()) (int)' (aka 'void (int)') cannot bind to a temporary of type 'int'}}
 void (&f3)(decltype(1 + 2)) = 0; // expected-error{{non-const lvalue reference to type 'void (decltype(1 + 2))' (aka 'void (int)') cannot bind to a temporary of type 'int'}}
 decltype(1+2) (&f4)(double, decltype(1 + 2)) = 0; // expected-error{{non-const lvalue reference to type 'decltype(1 + 2) (double, decltype(1 + 2))' (aka 'int (double, int)') cannot bind to a temporary of type 'int'}}
 auto (&f5)() -> decltype(1+2) = 0; // expected-error{{non-const lvalue reference to type 'auto () -> decltype(1 + 2)' (aka 'auto () -> int') cannot bind to a temporary of type 'int'}}
+
+using C = decltype(1+2);;
+C a6[10];
+extern C a8[];
+int a9 = a6; // expected-error{{cannot initialize a variable of type 'int' with an lvalue of type 'C[10]' (aka 'int[10]')}}
+int a10 = a8; // expected-error{{cannot initialize a variable of type 'int' with an lvalue of type 'C[]' (aka 'int[]')}}