[lldb] Centralize desugaring of decltype-like types in ClangASTContext

[labath]

Summary

These types were handled in some places, but not others. This resulted
in (for example) not being able to display members of structs whose
types were defined using these constructs.

Using getLocallyUnqualifiedSingleStepDesugaredType for these types is
not fully equivalent, as it will only desugar them if the types are not
instantiation-dependent, whereas previously we did that unconditionally.

It's not clear to me which behavior is correct here, but the test suite
does not seem to care either way.

[teemperor]

The change LGTM but the test could just be a unit test instead of doing the whole compile->start->attach->expr command cycle.

You can just add this to the TestClangASTContext.cpp to test the (nested) desugaring and the three types you covered (and one of the switch statements).

static QualType makeConstInt(clang::ASTContext &ctxt) {
  QualType result(ctxt.IntTy);
  result.addConst();
  return result;
}

TEST_F(TestClangASTContext, TestGetTypeClassDeclType) {
  clang::ASTContext &ctxt = *m_ast->getASTContext();
  auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
  QualType t = ctxt.getDecltypeType(nullptr_expr, makeConstInt(ctxt));
  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
}

TEST_F(TestClangASTContext, TestGetTypeClassTypeOf) {
  clang::ASTContext &ctxt = *m_ast->getASTContext();
  QualType t = ctxt.getTypeOfType(makeConstInt(ctxt));
  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
}

TEST_F(TestClangASTContext, TestGetTypeClassTypeOfExpr) {
  clang::ASTContext &ctxt = *m_ast->getASTContext();
  auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
  QualType t = ctxt.getTypeOfExprType(nullptr_expr);
  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
}

TEST_F(TestClangASTContext, TestGetTypeClassNested) {
  clang::ASTContext &ctxt = *m_ast->getASTContext();
  QualType t_base = ctxt.getTypeOfType(makeConstInt(ctxt));
  QualType t = ctxt.getTypeOfType(t_base);
  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
}

[labath]

The unit test sounds like a good idea. I'll do that instead.

lldb/source/Symbol/ClangASTContext.cpp

if (find(mask, type->getTypeClass()) != mask.end())
       return type;
     switch (type->getTypeClass()) {
     // This is not fully correct as _Atomic is more than sugar, but it is
     // sufficient for the purposes we care about.
     case clang::Type::Atomic:
       type = cast<clang::AtomicType>(type)->getValueType();
       break;
     case clang::Type::Auto:
+    case clang::Type::Decltype:
     case clang::Type::Elaborated:
     case clang::Type::Paren:
     case clang::Type::Typedef:
+    case clang::Type::TypeOf:
+    case clang::Type::TypeOfExpr:
       type = type->getLocallyUnqualifiedSingleStepDesugaredType();
       break;
     default:
       return type;
     }
   }
 }
 
case clang::Type::VariableArray:
     return eTypeHasChildren | eTypeIsArray;
 
   case clang::Type::DependentName:
     return 0;
   case clang::Type::DependentSizedExtVector:
     return eTypeHasChildren | eTypeIsVector;
   case clang::Type::DependentTemplateSpecialization:
     return eTypeIsTemplate;
-  case clang::Type::Decltype:
-    return CompilerType(this, llvm::cast<clang::DecltypeType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetTypeInfo(pointee_or_element_clang_type);
 
   case clang::Type::Enum:
     if (pointee_or_element_clang_type)
       pointee_or_element_clang_type->SetCompilerType(
           this, llvm::cast<clang::EnumType>(qual_type)
                     ->getDecl()
                     ->getIntegerType()
                     .getAsOpaquePtr());
ClangASTContext::GetTypeInfo(lldb::opaque_compiler_type_t type,
 
   case clang::Type::Typedef:
     return eTypeIsTypedef |
            CompilerType(this, llvm::cast<clang::TypedefType>(qual_type)
                                   ->getDecl()
                                   ->getUnderlyingType()
                                   .getAsOpaquePtr())
                .GetTypeInfo(pointee_or_element_clang_type);
-  case clang::Type::TypeOfExpr:
-    return CompilerType(this, llvm::cast<clang::TypeOfExprType>(qual_type)
-                                  ->getUnderlyingExpr()
-                                  ->getType()
-                                  .getAsOpaquePtr())
-        .GetTypeInfo(pointee_or_element_clang_type);
-  case clang::Type::TypeOf:
-    return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetTypeInfo(pointee_or_element_clang_type);
   case clang::Type::UnresolvedUsing:
     return 0;
 
   case clang::Type::ExtVector:
   case clang::Type::Vector: {
     uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
     const clang::VectorType *vector_type = llvm::dyn_cast<clang::VectorType>(
         qual_type->getCanonicalTypeInternal());
if (!type)
     return lldb::eTypeClassInvalid;
 
   clang::QualType qual_type =
       RemoveWrappingTypes(GetQualType(type), {clang::Type::Typedef});
 
   switch (qual_type->getTypeClass()) {
   case clang::Type::Atomic:
   case clang::Type::Auto:
+  case clang::Type::Decltype:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
+  case clang::Type::TypeOf:
+  case clang::Type::TypeOfExpr:
     llvm_unreachable("Handled in RemoveWrappingTypes!");
   case clang::Type::UnaryTransform:
     break;
   case clang::Type::FunctionNoProto:
     return lldb::eTypeClassFunction;
   case clang::Type::FunctionProto:
     return lldb::eTypeClassFunction;
   case clang::Type::IncompleteArray:
case clang::Type::InjectedClassName:
     break;
   case clang::Type::DependentName:
     break;
   case clang::Type::DependentTemplateSpecialization:
     break;
   case clang::Type::PackExpansion:
     break;
 
-  case clang::Type::TypeOfExpr:
-    return CompilerType(this, llvm::cast<clang::TypeOfExprType>(qual_type)
-                                  ->getUnderlyingExpr()
-                                  ->getType()
-                                  .getAsOpaquePtr())
-        .GetTypeClass();
-  case clang::Type::TypeOf:
-    return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetTypeClass();
-  case clang::Type::Decltype:
-    return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetTypeClass();
   case clang::Type::TemplateSpecialization:
     break;
   case clang::Type::DeducedTemplateSpecialization:
     break;
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
if (!type)
     return lldb::eEncodingInvalid;
 
   count = 1;
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
   case clang::Type::Atomic:
   case clang::Type::Auto:
+  case clang::Type::Decltype:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
   case clang::Type::Typedef:
+  case clang::Type::TypeOf:
+  case clang::Type::TypeOfExpr:
     llvm_unreachable("Handled in RemoveWrappingTypes!");
 
   case clang::Type::UnaryTransform:
     break;
 
   case clang::Type::FunctionNoProto:
   case clang::Type::FunctionProto:
     break;
lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
   }
 
   case clang::Type::ObjCInterface:
     break;
   case clang::Type::Record:
     break;
   case clang::Type::Enum:
     return lldb::eEncodingSint;
-  case clang::Type::TypeOfExpr:
-    return CompilerType(this, llvm::cast<clang::TypeOfExprType>(qual_type)
-                                  ->getUnderlyingExpr()
-                                  ->getType()
-                                  .getAsOpaquePtr())
-        .GetEncoding(count);
-  case clang::Type::TypeOf:
-    return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetEncoding(count);
-  case clang::Type::Decltype:
-    return CompilerType(this, llvm::cast<clang::DecltypeType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetEncoding(count);
   case clang::Type::DependentSizedArray:
   case clang::Type::DependentSizedExtVector:
   case clang::Type::UnresolvedUsing:
   case clang::Type::Attributed:
   case clang::Type::TemplateTypeParm:
   case clang::Type::SubstTemplateTypeParm:
   case clang::Type::SubstTemplateTypeParmPack:
   case clang::Type::InjectedClassName:
lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eFormatDefault;
 
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
 
   switch (qual_type->getTypeClass()) {
   case clang::Type::Atomic:
   case clang::Type::Auto:
+  case clang::Type::Decltype:
   case clang::Type::Elaborated:
   case clang::Type::Paren:
   case clang::Type::Typedef:
+  case clang::Type::TypeOf:
+  case clang::Type::TypeOfExpr:
     llvm_unreachable("Handled in RemoveWrappingTypes!");
   case clang::Type::UnaryTransform:
     break;
 
   case clang::Type::FunctionNoProto:
   case clang::Type::FunctionProto:
     break;
 
else
       return lldb::eFormatComplexInteger;
   }
   case clang::Type::ObjCInterface:
     break;
   case clang::Type::Record:
     break;
   case clang::Type::Enum:
     return lldb::eFormatEnum;
-  case clang::Type::TypeOfExpr:
-    return CompilerType(this, llvm::cast<clang::TypeOfExprType>(qual_type)
-                                  ->getUnderlyingExpr()
-                                  ->getType()
-                                  .getAsOpaquePtr())
-        .GetFormat();
-  case clang::Type::TypeOf:
-    return CompilerType(this, llvm::cast<clang::TypeOfType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetFormat();
-  case clang::Type::Decltype:
-    return CompilerType(this, llvm::cast<clang::DecltypeType>(qual_type)
-                                  ->getUnderlyingType()
-                                  .getAsOpaquePtr())
-        .GetFormat();
   case clang::Type::DependentSizedArray:
   case clang::Type::DependentSizedExtVector:
   case clang::Type::UnresolvedUsing:
   case clang::Type::Attributed:
   case clang::Type::TemplateTypeParm:
   case clang::Type::SubstTemplateTypeParm:
   case clang::Type::SubstTemplateTypeParmPack:
   case clang::Type::InjectedClassName:
uint32_t ClangASTContext::GetNumPointeeChildren(clang::QualType type) {
   case clang::Type::ExtVector:
     return 0;
   case clang::Type::FunctionProto:
     return 0; // When we function pointers, they have no children...
   case clang::Type::FunctionNoProto:
     return 0; // When we function pointers, they have no children...
   case clang::Type::UnresolvedUsing:
     return 0;
-  case clang::Type::TypeOfExpr:
-    return GetNumPointeeChildren(llvm::cast<clang::TypeOfExprType>(qual_type)
-                                     ->getUnderlyingExpr()
-                                     ->getType());
-  case clang::Type::TypeOf:
-    return GetNumPointeeChildren(
-        llvm::cast<clang::TypeOfType>(qual_type)->getUnderlyingType());
-  case clang::Type::Decltype:
-    return GetNumPointeeChildren(
-        llvm::cast<clang::DecltypeType>(qual_type)->getUnderlyingType());
   case clang::Type::Record:
     return 0;
   case clang::Type::Enum:
     return 1;
   case clang::Type::TemplateTypeParm:
     return 1;
   case clang::Type::SubstTemplateTypeParm:
     return 1;

lldb/unittests/Symbol/TestClangASTContext.cpp

 //===-- TestClangASTContext.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
-
-#include "clang/AST/DeclCXX.h"
-
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/ExprCXX.h"
+#include "gtest/gtest.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
 class TestClangASTContext : public testing::Test {
 public:
   static void SetUpTestCase() {
for (CompilerType t : {type, typedef_type, auto_type}) {
     EXPECT_EQ(m_ast->GetTypeTemplateArgument(t.GetOpaqueQualType(), 1),
               CompilerType());
     auto result = m_ast->GetIntegralTemplateArgument(t.GetOpaqueQualType(), 1);
     ASSERT_NE(llvm::None, result);
     EXPECT_EQ(arg, result->value);
     EXPECT_EQ(int_type, result->type);
   }
 }
+
+static QualType makeConstInt(clang::ASTContext &ctxt) {
+  QualType result(ctxt.IntTy);
+  result.addConst();
+  return result;
+}
+
+TEST_F(TestClangASTContext, TestGetTypeClassDeclType) {
+  clang::ASTContext &ctxt = *m_ast->getASTContext();
+  auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
+  QualType t = ctxt.getDecltypeType(nullptr_expr, makeConstInt(ctxt));
+  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
+}
+
+TEST_F(TestClangASTContext, TestGetTypeClassTypeOf) {
+  clang::ASTContext &ctxt = *m_ast->getASTContext();
+  QualType t = ctxt.getTypeOfType(makeConstInt(ctxt));
+  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
+}
+
+TEST_F(TestClangASTContext, TestGetTypeClassTypeOfExpr) {
+  clang::ASTContext &ctxt = *m_ast->getASTContext();
+  auto *nullptr_expr = new (ctxt) CXXNullPtrLiteralExpr(ctxt.NullPtrTy, SourceLocation());
+  QualType t = ctxt.getTypeOfExprType(nullptr_expr);
+  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
+}
+
+TEST_F(TestClangASTContext, TestGetTypeClassNested) {
+  clang::ASTContext &ctxt = *m_ast->getASTContext();
+  QualType t_base = ctxt.getTypeOfType(makeConstInt(ctxt));
+  QualType t = ctxt.getTypeOfType(t_base);
+  EXPECT_EQ(lldb::eTypeClassBuiltin, m_ast->GetTypeClass(t.getAsOpaquePtr()));
+}