[lldb] Let TypeSystemClang::GetDisplayTypeName remove anonymous and inline namespaces.

[teemperor]

Summary

Currently when printing data types we include implicit scopes such as inline namespaces or anonymous namespaces.
This leads to command output like this (for std::set<X> with X being in an anonymous namespace):

(lldb) print my_set
(std::__1::set<(anonymous namespace)::X, std::__1::less<(anonymous namespace)::X>, std::__1::allocator<(anonymous namespace)::X> >) $0 = size=0 {}

This patch removes all the implicit scopes when printing type names in TypeSystemClang::GetDisplayTypeName
so that our output now looks like this:

(lldb) print my_set
(std::set<X, std::less<X>, std::allocator<X> >) $0 = size=0 {}

As previously GetDisplayTypeName and GetTypeName had the same output we actually often used the
two as if they are the same method (they were in fact using the same implementation), so this patch also
fixes the places where we actually want the display type name and not the actual type name.

Note that this doesn't touch the GetTypeName class that for example the data formatters use, so this patch
is only changes the way we display types to the user. The full type name can also still be found when passing
'-R' to see the raw output of a variable in case someone is somehow interested in that.

Partly fixes rdar://problem/59292534

[shafik]

I can see how stripping __1 would be nice but I seeing (anonymous namespace) may be useful to know especially b/c it effects visibility and linkage. It would be nicer if could make this optional and default it off but be able to turn it back on.

[teemperor]

In D74478#1873581, @shafik wrote:

I can see how stripping __1 would be nice but I seeing (anonymous namespace) may be useful to know especially b/c it effects visibility and linkage. It would be nicer if could make this optional and default it off but be able to turn it back on.

You can always use the 'raw' output on variables (-R) for seeing all information about a variable and its type (including the full non-display name). Also I think the general consensus is that we print the types as close as possible as how the user is using them in the program (which is what for example Clang is doing in its diagnostics).

I updated the review description to better illustrate how verbose the anonymous/inline namespaces are in the type descriptions.

[jingham]

The only hesitation I have about this is if we are still printing this noise in demangled names, then the name of the type you see for a variable will be different from what you see when a method of that type ends up in a backtrace. That might be confusing. OTOH, the correct solution to that problem, IMO, is to remove the noise from backtraces, not keep it in the types...

[shafik]

If we still see the info using -R then I am happy but Jim's concerns are valid, they won't match the bracktrace.

[teemperor]

In D74478#1874746, @jingham wrote:

The only hesitation I have about this is if we are still printing this noise in demangled names, then the name of the type you see for a variable will be different from what you see when a method of that type ends up in a backtrace. That might be confusing. OTOH, the correct solution to that problem, IMO, is to remove the noise from backtraces, not keep it in the types...

I'm not entirely sure how/if we can make the backtraces nicer as we only have the function type (but not the specific function declaration with the name) and mangled/demangled name for them. Removing the anonymous namespace from the backtrace is doable with that, but inline namespaces and default template arguments (which are part of the radar) aren't possible unless we start doing much more work for the backtraces and figure out the actual FunctionDecls behind each function.

FWIW, the current way we express backtraces is anyway not identical to what we show in variables. Any typedefs and so on are lost in the mangled name, so stepping into std::string member functions brings users to a backtrace with in std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::foo. However printing the string shows them std::__1::string.

lldb/packages/Python/lldbsuite/test/lldbtest.py

def expect_expr(
             self.assertEqual(error_msg, eval_result.GetError().GetCString())
             return
 
         if not eval_result.GetError().Success():
             self.assertTrue(eval_result.GetError().Success(),
                 "Unexpected failure with msg: " + eval_result.GetError().GetCString())
 
         if result_type:
-            self.assertEqual(result_type, eval_result.GetTypeName())
+            self.assertEqual(result_type, eval_result.GetDisplayTypeName())
 
         if result_value:
             self.assertEqual(result_value, eval_result.GetValue())
 
         if result_summary:
             self.assertEqual(result_summary, eval_result.GetSummary())
 
     def invoke(self, obj, name, trace=False):

lldb/source/DataFormatters/FormatManager.cpp

entries.push_back(
         {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
     reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
   }
 
   if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
     entries.push_back(
         {type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
 
-    ConstString display_type_name(compiler_type.GetDisplayTypeName());
+    ConstString display_type_name(compiler_type.GetTypeName());
     if (display_type_name != type_name)
       entries.push_back({display_type_name, reason, did_strip_ptr,
                          did_strip_ref, did_strip_typedef});
   }
 
   for (bool is_rvalue_ref = true, j = true;
        j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
     CompilerType non_ref_type = compiler_type.GetNonReferenceType();

lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
   if (!head_type)
     return false;
 
   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 
   if (!template_type)
     return false;
 
-  stream.Printf(" Active Type = %s ", template_type.GetTypeName().GetCString());
+  stream << " Active Type = " << template_type.GetDisplayTypeName() << " ";
 
   return true;
 }
 } // namespace formatters
 } // namespace lldb_private
 
 namespace {
 class VariantFrontEnd : public SyntheticChildrenFrontEnd {

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

public:
   // Type Completion
 
   bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 
   // Accessors
 
   ConstString GetTypeName(lldb::opaque_compiler_type_t type) override;
 
-  ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override {
-    return GetTypeName(type);
-  }
+  ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type,
                        CompilerType *pointee_or_element_compiler_type) override;
 
   lldb::LanguageType
   GetMinimumLanguage(lldb::opaque_compiler_type_t type) override;
 
   lldb::TypeClass GetTypeClass(lldb::opaque_compiler_type_t type) override;

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

if (const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
     return ConstString(typedef_decl->getQualifiedNameAsString());
   }
 
   clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
   printing_policy.SuppressTagKeyword = true;
   return ConstString(qual_type.getAsString(printing_policy));
 }
 
+ConstString
+TypeSystemClang::GetDisplayTypeName(lldb::opaque_compiler_type_t type) {
+  if (!type)
+    return ConstString();
+
+  clang::QualType qual_type(GetQualType(type));
+  clang::PrintingPolicy printing_policy(getASTContext().getPrintingPolicy());
+  printing_policy.SuppressTagKeyword = true;
+  printing_policy.SuppressScope = false;
+  printing_policy.SuppressUnwrittenScope = true;
+  return ConstString(qual_type.getAsString(printing_policy));
+}
+
 uint32_t
 TypeSystemClang::GetTypeInfo(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_or_element_clang_type) {
   if (!type)
     return 0;
 
   if (pointee_or_element_clang_type)
     pointee_or_element_clang_type->Clear();

lldb/test/API/commands/expression/import-std-module/basic/TestImportStdModule.py

def test(self):
             "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
 
         # Activate importing of std module.
         self.runCmd("settings set target.import-std-module true")
         # Calling some normal std functions that return non-template types.
         self.expect_expr("std::abs(-42)", result_type="int", result_value="42")
         self.expect_expr("std::div(2, 1).quot", result_type="int", result_value="2")
         # Using types from std.
-        self.expect_expr("(std::size_t)33U", result_type="size_t", result_value="33")
+        self.expect_expr("(std::size_t)33U", result_type="std::size_t", result_value="33")
         # Calling templated functions that return non-template types.
         self.expect_expr("char char_a = 'b'; char char_b = 'a'; std::swap(char_a, char_b); char_a",
                     result_type="char", result_value="'a'")
 
     @add_test_categories(["libc++"])
     @skipIf(compiler=no_match("clang"))
     def test_non_cpp_language(self):
         self.build()

lldb/test/API/commands/expression/import-std-module/conflicts/TestStdModuleWithConflicts.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
             "// Set break point at this line.", lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
         self.expect_expr("std::abs(-42)", result_type="int", result_value="42")
         self.expect_expr("std::div(2, 1).quot", result_type="int", result_value="2")
-        self.expect_expr("(std::size_t)33U", result_type="size_t", result_value="33")
+        self.expect_expr("(std::size_t)33U", result_type="std::size_t", result_value="33")
         self.expect("expr char char_a = 'b'; char char_b = 'a'; std::swap(char_a, char_b); char_a",
                     substrs=["(char) $3 = 'a'"])

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/forward_list/TestDataFormatterLibcxxForwardList.py

 
 class TestDataFormatterLibcxxForwardList(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// break here')
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test(self):
         """Test that std::forward_list is displayed correctly"""
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/iterator/TestDataFormatterLibccIterator.py

class LibcxxIteratorDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that libc++ iterators format properly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/map/TestDataFormatterLibccMap.py

 
 class LibcxxMapDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         bkpt = self.target().FindBreakpointByID(

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/multimap/TestDataFormatterLibccMultiMap.py

 
 
 class LibcxxMultiMapDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         bkpt = self.target().FindBreakpointByID(

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

 
 
 class LibcxxMultiSetDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     def getVariableType(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
-        return var.GetType().GetCanonicalType().GetName()
+        return var.GetType().GetDisplayTypeName()
 
     def check_ii(self, var_name):
         """ This checks the value of the bitset stored in ii at the call to by_ref_and_ptr.
             We use this to make sure we get the same values for ii when we look at the object
             directly, and when we look at a reference to the object. """
         self.expect(
             "frame variable " + var_name,
             substrs=["size=7",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/main.cpp

 #include <string>
 #include <set>
 
-typedef std::multiset<int> intset;
-typedef std::multiset<std::string> stringset;
-
 int g_the_foo = 0;
 
 int thefoo_rw(int arg = 1)
 {
   if (arg < 0)
     arg = 0;
   if (!arg)
     arg = 1;
   g_the_foo += arg;
   return g_the_foo;
 }
 
-void by_ref_and_ptr(intset &ref, intset *ptr)
+void by_ref_and_ptr(std::multiset<int> &ref, std::multiset<int> *ptr)
 {
     // Stop here to check by ref and ptr
     return;
 } 
 
 int main()
 {
-    intset ii;
+    std::multiset<int> ii;
     thefoo_rw(1);  // Set break point at this line.
   
   ii.insert(0);
   ii.insert(1);
   ii.insert(2);
   ii.insert(3);
   ii.insert(4);
   ii.insert(5);
     thefoo_rw(1);  // Set break point at this line.
 
   ii.insert(6);
   thefoo_rw(1);  // Set break point at this line.
 
         by_ref_and_ptr(ii, &ii);
 
   ii.clear();
   thefoo_rw(1);  // Set break point at this line.
 
-  stringset ss;
+  std::multiset<std::string> ss;
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("a");
   ss.insert("a very long string is right here");
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("b");
   ss.insert("c");
   thefoo_rw(1);  // Set break point at this line.
   
   ss.erase("b");
   thefoo_rw(1);  // Set break point at this line.
 
     return 0;
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/queue/TestDataFormatterLibcxxQueue.py

 
 
 class TestDataFormatterLibcxxQueue(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     def check_variable(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
 
         queue = self.namespace + '::queue'
-        self.assertTrue(queue in var.GetTypeName())
+        self.assertTrue(queue in var.GetDisplayTypeName())
         self.assertEqual(var.GetNumChildren(), 5)
         for i in range(5):
             ch = var.GetChildAtIndex(i)
             self.assertTrue(ch.IsValid())
             self.assertEqual(ch.GetValueAsSigned(), i+1)
 
     @expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android")
     @add_test_categories(["libc++"])
     def test(self):
         """Test that std::queue is displayed correctly"""
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.check_variable('q1')
         self.check_variable('q2')

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py

 
 
 class LibcxxSetDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     def getVariableType(self, name):
         var = self.frame().FindVariable(name)
         self.assertTrue(var.IsValid())
-        return var.GetType().GetCanonicalType().GetName()
+        return var.GetType().GetDisplayTypeName()
 
     def check_ii(self, var_name):
         """ This checks the value of the bitset stored in ii at the call to by_ref_and_ptr.
             We use this to make sure we get the same values for ii when we look at the object
             directly, and when we look at a reference to the object. """
         self.expect(
             "frame variable " + var_name,
             substrs=["size=7",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/set/main.cpp

 #include <string>
 #include <set>
 
-typedef std::set<int> intset;
-typedef std::set<std::string> stringset;
-
 int g_the_foo = 0;
 
 int thefoo_rw(int arg = 1)
 {
   if (arg < 0)
     arg = 0;
   if (!arg)
     arg = 1;
   g_the_foo += arg;
   return g_the_foo;
 }
 
-void by_ref_and_ptr(intset &ref, intset *ptr)
+void by_ref_and_ptr(std::set<int> &ref, std::set<int> *ptr)
 {
     // Stop here to check by ref and ptr
     return;
 } 
 
 int main()
 {
-    intset ii;
+    std::set<int> ii;
     thefoo_rw(1);  // Set break point at this line.
   
   ii.insert(0);
   ii.insert(1);
   ii.insert(2);
   ii.insert(3);
   ii.insert(4);
   ii.insert(5);
     thefoo_rw(1);  // Set break point at this line.
 
   ii.insert(6);
   thefoo_rw(1);  // Set break point at this line.
 
         by_ref_and_ptr(ii, &ii);
 
   ii.clear();
   thefoo_rw(1);  // Set break point at this line.
 
-  stringset ss;
+  std::set<std::string> ss;
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("a");
   ss.insert("a very long string is right here");
   thefoo_rw(1);  // Set break point at this line.
 
   ss.insert("b");
   ss.insert("c");
   thefoo_rw(1);  // Set break point at this line.
   
   ss.erase("b");
   thefoo_rw(1);  // Set break point at this line.
 
     return 0;
 }

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

class LibcxxStringDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     @expectedFailureAll(bugnumber="llvm.org/pr36109", debug_info="gmodules", triple=".*-android")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/tuple/TestDataFormatterLibcxxTuple.py

 
 class TestDataFormatterLibcxxTuple(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// break here')
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test(self):
         """Test that std::tuple is displayed correctly"""
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unordered/TestDataFormatterUnordered.py

 
 
 class LibcxxUnorderedDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        ns = 'ndk' if lldbplatformutil.target_is_android() else ''
-        self.namespace = 'std::__' + ns + '1'
+        self.namespace = 'std'
 
     @add_test_categories(["libc++"])
     def test_with_run_command(self):
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_source_regexp(
             self, "Set break point at this line.")

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/variant/TestDataFormatterLibcxxVariant.py

def test_with_run_command(self):
                                '}'])
 
         self.expect("frame variable v1_ref",
                 substrs=['v1_ref =  Active Type = int : {',
                                'Value = 12',
                                '}'])
 
         self.expect("frame variable v_v1",
-                substrs=['v_v1 =  Active Type = std::__1::variant<int, double, char>  {',
+                substrs=['v_v1 =  Active Type = std::variant<int, double, char>  {',
                                  'Value =  Active Type = int  {',
                                    'Value = 12',
                                  '}',
                                '}'])
 
         lldbutil.continue_to_breakpoint(self.process, bkpt)
 
         self.expect("frame variable v1",

lldb/test/Shell/SymbolFile/NativePDB/ast-types.cpp

 // CHECK: (A::B::C<void>) ABCVoid = (ABCSpecializationMember = 0x{{0+}})
 // CHECK: (A::C<0>) AC0 = {}
 // CHECK: (A::C<-1>) ACNeg1 = {}
 // CHECK: (A::C<1>::D) AC1D = (ACDMember = 0, CPtr = 0x{{0+}})
 // CHECK: (A::C<0>::D) AC0D = (ACDMember = 0, CPtr = 0x{{0+}})
 // CHECK: (A::C<-1>::D) ACNeg1D = (ACDMember = 0, CPtr = 0x{{0+}})
 // CHECK: (A::D) AD = {}
 // CHECK: (A::D::E) ADE = (ADDMember = 0)
-// CHECK: ((anonymous namespace)::Anonymous<int>) AnonInt = (AnonymousMember = 0)
-// CHECK: ((anonymous namespace)::Anonymous<A::B::C<void>>) AnonABCVoid = (AnonymousMember = 0)
-// CHECK: ((anonymous namespace)::Anonymous<A::B::C<void>>::D) AnonABCVoidD = (AnonymousDMember = 0)
+// CHECK: (Anonymous<int>) AnonInt = (AnonymousMember = 0)
+// CHECK: (Anonymous<A::B::C<void>>) AnonABCVoid = (AnonymousMember = 0)
+// CHECK: (Anonymous<A::B::C<void>>::D) AnonABCVoidD = (AnonymousDMember = 0)
 // CHECK: Dumping clang ast for 1 modules.
 // CHECK: TranslationUnitDecl {{.*}}
 // CHECK: |-CXXRecordDecl {{.*}} class TrivialC definition
 // CHECK: |-CXXRecordDecl {{.*}} struct TrivialS definition
 // CHECK: |-CXXRecordDecl {{.*}} union TrivialU definition
 // CHECK: |-EnumDecl {{.*}} TrivialE
 // CHECK: | `-EnumConstantDecl {{.*}} TE_A 'TrivialE'
 // CHECK: |-NamespaceDecl {{.*}} A