[lldb] Make TypeSystemClang::GetFullyUnqualifiedType work for constant arrays

[labath]

Summary

Unqualify (constant) arrays recursively, just like we do for pointers.
This allows for better pretty printer matching.

[teemperor]

LGTM, could you also extend a non-unit test to test the change within the whole FormatManager/etc. setup? I think TestDataFormatterAdv.py already has a very similar section about ignoring cv on types.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

4243

?

lldb/unittests/Symbol/TestTypeSystemClang.cpp

919

My head has a hard time parsing what those asserts do or test. Maybe add some summary above or something similar?

// unqualified(const volatile bool[47]) -> bool[47]

[labath]

new version

[labath]

In D112708#3093252, @teemperor wrote:

LGTM, could you also extend a non-unit test to test the change within the whole FormatManager/etc. setup? I think TestDataFormatterAdv.py already has a very similar section about ignoring cv on types.

I've added a simple check to that test. I didn't want to go overboard, as I already have an made an exhaustive test in the follow-up patch.

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

4243

oops

[teemperor]

In D112708#3093318, @labath wrote:

In D112708#3093252, @teemperor wrote:

LGTM, could you also extend a non-unit test to test the change within the whole FormatManager/etc. setup? I think TestDataFormatterAdv.py already has a very similar section about ignoring cv on types.

I've added a simple check to that test. I didn't want to go overboard, as I already have an made an exhaustive test in the follow-up patch.

Fair, LGTM then.

[shafik]

LGTM

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

TypeSystemClang::GetCanonicalType(lldb::opaque_compiler_type_t type) {
   return CompilerType();
 }
 
 static clang::QualType GetFullyUnqualifiedType_Impl(clang::ASTContext *ast,
                                                     clang::QualType qual_type) {
   if (qual_type->isPointerType())
     qual_type = ast->getPointerType(
         GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
-  else
+  else if (const ConstantArrayType *arr =
+               ast->getAsConstantArrayType(qual_type)) {
+    qual_type = ast->getConstantArrayType(
+        GetFullyUnqualifiedType_Impl(ast, arr->getElementType()),
+        arr->getSize(), arr->getSizeExpr(), arr->getSizeModifier(),
+        arr->getIndexTypeQualifiers().getAsOpaqueValue());
+  } else
     qual_type = qual_type.getUnqualifiedType();
   qual_type.removeLocalConst();
   qual_type.removeLocalRestrict();
   qual_type.removeLocalVolatile();
   return qual_type;
 }
 
 CompilerType

lldb/test/API/functionalities/data-formatter/data-formatter-advanced/TestDataFormatterAdv.py

def test_with_run_command(self):
         self.runCmd("type summary delete i_am_cool")
 
         self.expect("frame variable cool_boy",
                     substrs=['pluto'])
 
         self.runCmd("type summary clear")
 
         self.runCmd(
-            "type summary add --summary-string \"${var[]}\" -x \"int\\[[0-9]\\]")
+            "type summary add --summary-string \"${var[]}\" -x \"^int\\[[0-9]\\]")
 
         self.expect("frame variable int_array",
                     substrs=['1,2,3,4,5'])
+        self.expect("frame variable const_int_array",
+                    substrs=['11,12,13,14,15'])
 
         # this will fail if we don't do [] as regex correctly
         self.runCmd(
             'type summary add --summary-string "${var[].integer}" "i_am_cool[]')
 
         self.expect("frame variable cool_array",
                     substrs=['1,1,1,1,6'])
 

lldb/test/API/functionalities/data-formatter/data-formatter-advanced/main.cpp

i_am_cool *cool_pointer = new i_am_cool(3,-3.141592,'E');
     
     i_am_cool cool_array[5];
     
     cool_array[3].floating = 5.25;
     cool_array[4].integer = 6;
     cool_array[2].character = 'Q';
     
     int int_array[] = {1,2,3,4,5};
-    
+    const int const_int_array[] = {11, 12, 13, 14, 15};
     IWrapPointers wrapper;
         
     *int_array = -1;
     
     int* pointer = &cool_array[4].integer;
     
     IWrapPointers *wrap_pointer = &wrapper;
     

lldb/unittests/Symbol/TestTypeSystemClang.cpp

TEST_F(TestTypeSystemClang, AddMethodToObjCObjectType) {
 
   // Test some properties of the created ObjCMethodDecl.
   EXPECT_FALSE(method->isVariadic());
   EXPECT_TRUE(method->isImplicit());
   EXPECT_FALSE(method->isDirectMethod());
   EXPECT_EQ(method->getDeclName().getObjCSelector().getAsString(), "foo");
 }
 
+TEST_F(TestTypeSystemClang, GetFullyUnqualifiedType) {
+  CompilerType bool_ = m_ast->GetBasicType(eBasicTypeBool);
+  CompilerType cv_bool = bool_.AddConstModifier().AddVolatileModifier();
+
+  // const volatile bool -> bool
+  EXPECT_EQ(bool_, cv_bool.GetFullyUnqualifiedType());
+
+  // const volatile bool[47] -> bool[47]
+  EXPECT_EQ(bool_.GetArrayType(47),
+            cv_bool.GetArrayType(47).GetFullyUnqualifiedType());
+
+  // const volatile bool[47][42] -> bool[47][42]
+  EXPECT_EQ(
+      bool_.GetArrayType(42).GetArrayType(47),
+      cv_bool.GetArrayType(42).GetArrayType(47).GetFullyUnqualifiedType());
+
+  // const volatile bool * -> bool *
+  EXPECT_EQ(bool_.GetPointerType(),
+            cv_bool.GetPointerType().GetFullyUnqualifiedType());
+
+  // const volatile bool *[47] -> bool *[47]
+  EXPECT_EQ(
+      bool_.GetPointerType().GetArrayType(47),
+      cv_bool.GetPointerType().GetArrayType(47).GetFullyUnqualifiedType());
+}
+
 TEST(TestScratchTypeSystemClang, InferSubASTFromLangOpts) {
   LangOptions lang_opts;
   EXPECT_EQ(
       ScratchTypeSystemClang::DefaultAST,
       ScratchTypeSystemClang::InferIsolatedASTKindFromLangOpts(lang_opts));
 
   lang_opts.Modules = true;
   EXPECT_EQ(