Add SBType::IsAnonymousType() and relative plumbing in the debugger internals

For language that support such a thing, this API allows to ask whether a type is anonymous (i.e. has been given no name)

Comes with test case

llvm-svn: 252390

lldb/include/lldb/API/SBType.h

@@ -158,6 +158,9 @@ public:
     bool
     IsTypedefType ();
     
+    bool
+    IsAnonymousType ();
+    
     lldb::SBType
     GetPointerType();
     

lldb/include/lldb/Symbol/ClangASTContext.h

@@ -605,6 +605,9 @@ public:
     bool
     IsAggregateType (lldb::opaque_compiler_type_t type) override;
     
+    bool
+    IsAnonymousType (lldb::opaque_compiler_type_t type) override;
+    
     bool
     IsBeingDefined (lldb::opaque_compiler_type_t type) override;
     

lldb/include/lldb/Symbol/CompilerType.h

@@ -106,6 +106,9 @@ public:
     bool
     IsAggregateType () const;
     
+    bool
+    IsAnonymousType () const;
+    
     bool
     IsBeingDefined () const;
 

lldb/include/lldb/Symbol/TypeSystem.h

@@ -153,6 +153,9 @@ public:
     
     virtual bool
     IsAggregateType (lldb::opaque_compiler_type_t type) = 0;
+
+    virtual bool
+    IsAnonymousType (lldb::opaque_compiler_type_t type);
     
     virtual bool
     IsCharType (lldb::opaque_compiler_type_t type) = 0;

lldb/packages/Python/lldbsuite/test/python_api/type/TestTypeList.py

@@ -59,11 +59,16 @@ class TypeAndTypeListTestCase(TestBase):
         for type in type_list:
             self.assertTrue(type)
             self.DebugSBType(type)
+            self.assertFalse(type.IsAnonymousType(), "Task is not anonymous")
             for field in type.fields:
                 if field.name == "type":
                     for enum_member in field.type.enum_members:
                         self.assertTrue(enum_member)
                         self.DebugSBType(enum_member.type)
+                elif field.name == "my_type_is_nameless":
+                    self.assertTrue(field.type.IsAnonymousType(), "my_type_is_nameless has an anonymous type")
+                elif field.name == "my_type_is_named":
+                    self.assertFalse(field.type.IsAnonymousType(), "my_type_is_named has a named type")
 
         # Pass an empty string.  LLDB should not crash. :-)
         fuzz_types = target.FindTypes(None)

lldb/packages/Python/lldbsuite/test/python_api/type/main.cpp

@@ -16,6 +16,12 @@ public:
         TASK_TYPE_1,
         TASK_TYPE_2
     } type;
+    struct {
+      int x;
+    } my_type_is_nameless;
+    struct name {
+      int x;
+    } my_type_is_named;
     Task(int i, Task *n):
         id(i),
         next(n),

lldb/scripts/interface/SBType.i

@@ -215,6 +215,9 @@ public:
     bool
     IsTypedefType ();
     
+    bool
+    IsAnonymousType ();
+    
     lldb::SBType
     GetPointerType();
 

lldb/source/API/SBType.cpp

@@ -264,6 +264,14 @@ SBType::IsTypedefType ()
     return m_opaque_sp->GetCompilerType(true).IsTypedefType();
 }
 
+bool
+SBType::IsAnonymousType ()
+{
+    if (!IsValid())
+        return false;
+    return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
+}
+
 lldb::SBType
 SBType::GetFunctionReturnType ()
 {

lldb/source/Symbol/ClangASTContext.cpp

@@ -2584,6 +2584,38 @@ ClangASTContext::IsAggregateType (lldb::opaque_compiler_type_t type)
     return false;
 }
 
+bool
+ClangASTContext::IsAnonymousType (lldb::opaque_compiler_type_t type)
+{
+    clang::QualType qual_type (GetCanonicalQualType(type));
+    
+    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
+    switch (type_class)
+    {
+        case clang::Type::Record:
+        {
+            if (const clang::RecordType *record_type = llvm::dyn_cast_or_null<clang::RecordType>(qual_type.getTypePtrOrNull()))
+            {
+                if (const clang::RecordDecl *record_decl = record_type->getDecl())
+                {
+                    return record_decl->isAnonymousStructOrUnion();
+                }
+            }
+            break;
+        }
+        case clang::Type::Elaborated:
+            return IsAnonymousType(llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
+        case clang::Type::Typedef:
+            return IsAnonymousType(llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
+        case clang::Type::Paren:
+            return IsAnonymousType(llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr());
+        default:
+            break;
+    }
+    // The clang type does have a value
+    return false;
+}
+
 bool
 ClangASTContext::IsArrayType (lldb::opaque_compiler_type_t type,
                               CompilerType *element_type_ptr,

lldb/source/Symbol/CompilerType.cpp

@@ -63,6 +63,14 @@ CompilerType::IsAggregateType () const
     return false;
 }
 
+bool
+CompilerType::IsAnonymousType () const
+{
+    if (IsValid())
+        return m_type_system->IsAnonymousType(m_type);
+    return false;
+}
+
 bool
 CompilerType::IsArrayType (CompilerType *element_type_ptr,
                            uint64_t *size,

lldb/source/Symbol/TypeSystem.cpp

@@ -55,6 +55,12 @@ TypeSystem::CreateInstance (lldb::LanguageType language, Target *target)
     return lldb::TypeSystemSP();
 }
 
+bool
+TypeSystem::IsAnonymousType (lldb::opaque_compiler_type_t type)
+{
+    return false;
+}
+
 CompilerType
 TypeSystem::GetLValueReferenceType (lldb::opaque_compiler_type_t type)
 {