Add SBType::IsScopedEnumerationType method

[werat]

Summary

Add a method to check if the type is a scoped enumeration (i.e. "enum class/struct").

[JDevlieghere]

lldb/source/API/SBType.cpp

275

Same comment as in D93696: you need to register your new method.

[werat]

Register the new method using lldb-instr.

[werat]

lldb/source/API/SBType.cpp

275

Thanks for pointing this out, I totally missed it.

[JDevlieghere]

LGTM

lldb/bindings/interface/SBType.i

public:
     IsVectorType ();
 
     bool
     IsTypedefType ();
 
     bool
     IsAnonymousType ();
 
+    bool
+    IsScopedEnumerationType ();
+
     lldb::SBType
     GetPointerType();
 
     lldb::SBType
     GetPointeeType();
 
     lldb::SBType
     GetReferenceType();

lldb/include/lldb/API/SBType.h

public:
   bool IsArrayType();
 
   bool IsVectorType();
 
   bool IsTypedefType();
 
   bool IsAnonymousType();
 
+  bool IsScopedEnumerationType();
+
   lldb::SBType GetPointerType();
 
   lldb::SBType GetPointeeType();
 
   lldb::SBType GetReferenceType();
 
   lldb::SBType GetTypedefedType();
 

lldb/include/lldb/Symbol/CompilerType.h

public:
   bool IsVectorType(CompilerType *element_type, uint64_t *size) const;
 
   bool IsArrayOfScalarType() const;
 
   bool IsAggregateType() const;
 
   bool IsAnonymousType() const;
 
+  bool IsScopedEnumerationType() const;
+
   bool IsBeingDefined() const;
 
   bool IsCharType() const;
 
   bool IsCompleteType() const;
 
   bool IsConst() const;
 

lldb/include/lldb/Symbol/TypeSystem.h

virtual bool IsIntegerType(lldb::opaque_compiler_type_t type,
                              bool &is_signed) = 0;
 
   virtual bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                                  bool &is_signed) {
     is_signed = false;
     return false;
   }
 
+  virtual bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) = 0;
+
   virtual bool IsPossibleDynamicType(lldb::opaque_compiler_type_t type,
                                      CompilerType *target_type, // Can pass NULL
                                      bool check_cplusplus, bool check_objc) = 0;
 
   virtual bool IsPointerType(lldb::opaque_compiler_type_t type,
                              CompilerType *pointee_type) = 0;
 
   virtual bool IsScalarType(lldb::opaque_compiler_type_t type) = 0;

lldb/source/API/SBType.cpp

 bool SBType::IsAnonymousType() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsAnonymousType);
 
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
 }
 
+bool SBType::IsScopedEnumerationType() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBType, IsScopedEnumerationType);
+
+  if (!IsValid())
+    return false;
+  return m_opaque_sp->GetCompilerType(true).IsScopedEnumerationType();
+}
+
 lldb::SBType SBType::GetFunctionReturnType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBType, GetFunctionReturnType);
 
   if (IsValid()) {
     CompilerType return_type(
         m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
     if (return_type.IsValid())
       return LLDB_RECORD_RESULT(SBType(return_type));
void RegisterMethods<SBType>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetDereferencedType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayElementType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetArrayType, (uint64_t));
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetVectorElementType, ());
   LLDB_REGISTER_METHOD(bool, SBType, IsFunctionType, ());
   LLDB_REGISTER_METHOD(bool, SBType, IsPolymorphicClass, ());
   LLDB_REGISTER_METHOD(bool, SBType, IsTypedefType, ());
   LLDB_REGISTER_METHOD(bool, SBType, IsAnonymousType, ());
+  LLDB_REGISTER_METHOD(bool, SBType, IsScopedEnumerationType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetFunctionReturnType, ());
   LLDB_REGISTER_METHOD(lldb::SBTypeList, SBType, GetFunctionArgumentTypes,
                        ());
   LLDB_REGISTER_METHOD(uint32_t, SBType, GetNumberOfMemberFunctions, ());
   LLDB_REGISTER_METHOD(lldb::SBTypeMemberFunction, SBType,
                        GetMemberFunctionAtIndex, (uint32_t));
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetUnqualifiedType, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBType, GetCanonicalType, ());

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

bool IsBlockPointerType(lldb::opaque_compiler_type_t type,
                           CompilerType *function_pointer_type_ptr) override;
 
   bool IsIntegerType(lldb::opaque_compiler_type_t type,
                      bool &is_signed) override;
 
   bool IsEnumerationType(lldb::opaque_compiler_type_t type,
                          bool &is_signed) override;
 
+  bool IsScopedEnumerationType(lldb::opaque_compiler_type_t type) override;
+
   static bool IsObjCClassType(const CompilerType &type);
 
   static bool IsObjCClassTypeAndHasIVars(const CompilerType &type,
                                          bool check_superclass);
 
   static bool IsObjCObjectOrInterfaceType(const CompilerType &type);
 
   static bool IsObjCObjectPointerType(const CompilerType &type,

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

if (enum_type) {
                     is_signed);
       return true;
     }
   }
 
   return false;
 }
 
+bool TypeSystemClang::IsScopedEnumerationType(
+    lldb::opaque_compiler_type_t type) {
+  if (type) {
+    const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
+        GetCanonicalQualType(type)->getCanonicalTypeInternal());
+
+    if (enum_type) {
+      return enum_type->isScopedEnumeralType();
+    }
+  }
+
+  return false;
+}
+
 bool TypeSystemClang::IsPointerType(lldb::opaque_compiler_type_t type,
                                     CompilerType *pointee_type) {
   if (type) {
     clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class) {
     case clang::Type::Builtin:
       switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {

lldb/source/Symbol/CompilerType.cpp

 }
 
 bool CompilerType::IsAnonymousType() const {
   if (IsValid())
     return m_type_system->IsAnonymousType(m_type);
   return false;
 }
 
+bool CompilerType::IsScopedEnumerationType() const {
+  if (IsValid())
+    return m_type_system->IsScopedEnumerationType(m_type);
+  return false;
+}
+
 bool CompilerType::IsArrayType(CompilerType *element_type_ptr, uint64_t *size,
                                bool *is_incomplete) const {
   if (IsValid())
     return m_type_system->IsArrayType(m_type, element_type_ptr, size,
                                       is_incomplete);
 
   if (element_type_ptr)
     element_type_ptr->Clear();

lldb/test/API/python_api/type/TestTypeList.py

def test(self):
         myint_arr_type = myint_arr.GetType()
         self.DebugSBType(myint_arr_type)
         self.assertTrue(myint_arr_type.IsArrayType())
         myint_arr_element_type = myint_arr_type.GetArrayElementType()
         self.DebugSBType(myint_arr_element_type)
         myint_type = target.FindFirstType('myint')
         self.DebugSBType(myint_type)
         self.assertTrue(myint_arr_element_type == myint_type)
+
+        # Test enum methods.
+        enum_type = target.FindFirstType('EnumType')
+        self.assertTrue(enum_type)
+        self.DebugSBType(enum_type)
+        self.assertFalse(enum_type.IsScopedEnumerationType())
+        scoped_enum_type = target.FindFirstType('ScopedEnumType')
+        self.assertTrue(scoped_enum_type)
+        self.DebugSBType(scoped_enum_type)
+        self.assertTrue(scoped_enum_type.IsScopedEnumerationType())

lldb/test/API/python_api/type/main.cpp

public:
     } my_type_is_named;
     Task(int i, Task *n):
         id(i),
         next(n),
         type(TASK_TYPE_1)
     {}
 };
 
+enum EnumType {};
+enum class ScopedEnumType {};
 
 int main (int argc, char const *argv[])
 {
     Task *task_head = new Task(-1, NULL);
     Task *task1 = new Task(1, NULL);
     Task *task2 = new Task(2, NULL);
     Task *task3 = new Task(3, NULL); // Orphaned.
     Task *task4 = new Task(4, NULL);
int main (int argc, char const *argv[])
     printf("We have a total number of %d tasks\n", total);
 
     // This corresponds to an empty task list.
     Task *empty_task_head = new Task(-1, NULL);
 
     typedef int myint;
     myint myint_arr[] = {1, 2, 3};
 
+    EnumType enum_type;
+    ScopedEnumType scoped_enum_type;
+
     return 0; // Break at this line
 }