[lldb] Ignore certain Clang type sugar when creating the type name

[teemperor]

Summary

Clang has some type sugar that only serves as a way to preserve the way
a user has typed a certain type in the source code. These types are currently
not unwrapped when we query the type name for a Clang type, which means
that this type sugar actually influences what formatters are picked for a certain
type. Currently if a user decides to reference a type by doing ::GlobalDecl Var = 3;,
the type formatter for GlobalDecl will not be used (as the type sugar around the
type gives it the name ::GlobalDecl. The same goes for other ways to spell out
a type such as auto etc.

With this patch most of this type sugar gets stripped when the full type name is
calculated. Typedefs are not getting desugared as that seems counterproductive.
I also don't desugar atomic types as that's technically not type sugar.

[jarin]

This makes sense, thanks!

Since your main motivation is formatter selection, you might want to consider adding a formatting test, too. To be precise, I see that you have a formatting test for typedef already, but that one would pass even without your change (as far as I can see). I mean a formatting test for the case described in your patch summary, that one should fail without your patch.

[teemperor]

In D87481#2270919, @jarin wrote:

This makes sense, thanks!

Since your main motivation is formatter selection, you might want to consider adding a formatting test, too. To be precise, I see that you have a formatting test for typedef already, but that one would pass even without your change (as far as I can see). I mean a formatting test for the case described in your patch summary, that one should fail without your patch.

Good point! It seems I broke the last test while simplifying it to use a typedef which has its own special code path. I'll go back to using the record type also for last part of the test.

[teemperor]

• Don't use a typedef in the formatter test case (which already has a special code path) but just a struct.

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

 }
 
 ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type) {
   if (!type)
     return ConstString();
 
   clang::QualType qual_type(GetQualType(type));
 
+  // Remove certain type sugar from the name. Sugar such as elaborated types
+  // or template types which only serve to improve diagnostics shouldn't
+  // act as their own types from the user's perspective (e.g., formatter
+  // shouldn't format a variable differently depending on how the ser has
+  // specified the type. '::Type' and 'Type' should behave the same).
+  // Typedefs and atomic derived types are not removed as they are actually
+  // useful for identifiying specific types.
+  qual_type = RemoveWrappingTypes(qual_type,
+                                  {clang::Type::Typedef, clang::Type::Atomic});
+
   // For a typedef just return the qualified name.
   if (const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
     const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
     return ConstString(typedef_decl->getQualifiedNameAsString());
   }
 
   clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
   printing_policy.SuppressTagKeyword = true;

lldb/test/API/lang/cpp/elaborated-types/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/lang/cpp/elaborated-types/TestElaboratedTypes.py

+"""
+Test elaborated types (e.g. Clang's ElaboratedType or TemplateType sugar).
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    def test(self):
+        self.build()
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        # Add a type formatter for 'Struct'.
+        self.expect("type summary add Struct --summary-string '(summary x=${var.x})'")
+        # Check that creating an expr with an elaborated type ('::Struct')
+        # triggers our formatter for 'Struct' while keeping the elaborated type
+        # as the display type.
+        result = self.expect_expr("::Struct s; s.x = 4; s",
+                                  result_type="::Struct",
+                                  result_summary="(summary x=4)")
+        # Test that a plain elaborated type is only in the display type name but
+        # not in the full type name.
+        self.assertEqual(result.GetTypeName(), "Struct")
+
+        # Test the same for template types (that also only act as sugar to better
+        # show how the template was specified by the user).
+
+        # Declare a template that can actually be instantiated.
+        # FIXME: The error message here is incorrect.
+        self.expect("expr --top-level -- template<typename T> struct $V {};",
+                    error=True, substrs=["Couldn't find $__lldb_expr() in the module"])
+        result = self.expect_expr("$V<::Struct> s; s",
+                                  result_type="$V< ::Struct>")
+        self.assertEqual(result.GetTypeName(), "$V<Struct>")

lldb/test/API/lang/cpp/elaborated-types/main.cpp

+struct Struct {
+  int x;
+};
+
+int main() {
+  Struct use;
+  use.x = 3;
+  return use.x; // break here
+}