[lldb] Don't crash when printing static enum members with bool as underlying type

[aeubanks]

Summary

Undoes a lot of the code added in D135169 to piggyback off of the enum logic in TypeSystemClang::SetIntegerInitializerForVariable().

Fixes #58383.

[DavidSpickett]

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

7612

Can you call TypeSystemClang::IsBooleanType from here instead?

[aeubanks]

undo a lot of code added in D135169. it seems a little overengineered when we can just check if the type is bool when setting the initializer.

[aeubanks]

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

7612

better?

[aeubanks]

capitalize comment

[DavidSpickett]

LGTM

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

7612

Much!

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

 bool TypeSystemClang::IsBooleanType(lldb::opaque_compiler_type_t type) {
   if (!type)
     return false;
 
   clang::QualType qual_type(GetCanonicalQualType(type));
   const clang::BuiltinType *builtin_type =
       llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
 
+  if (!builtin_type) {
+    if (const clang::EnumType *enum_type = llvm::dyn_cast<clang::EnumType>(
+            qual_type->getCanonicalTypeInternal())) {
+      builtin_type = llvm::dyn_cast<clang::BuiltinType>(
+          enum_type->getDecl()->getIntegerType());
+    }
+  }
+
   if (!builtin_type)
     return false;
 
   return builtin_type->isBooleanType();
 }
 
 bool TypeSystemClang::IsEnumerationType(lldb::opaque_compiler_type_t type,
                                         bool &is_signed) {
clang::VarDecl *TypeSystemClang::AddVariableToRecordType(
 
   return var_decl;
 }
 
 void TypeSystemClang::SetBoolInitializerForVariable(VarDecl *var, bool value) {
   assert(!var->hasInit() && "variable already initialized");
 
   QualType qt = var->getType();
-  assert(qt->isSpecificBuiltinType(BuiltinType::Bool) &&
+  assert((qt->isSpecificBuiltinType(BuiltinType::Bool) ||
+          cast<clang::EnumType>(qt)
+              ->getDecl()
+              ->getIntegerType()
+              ->isSpecificBuiltinType(BuiltinType::Bool)) &&
          "only boolean supported");
 
   clang::ASTContext &ast = var->getASTContext();
   var->setInit(CXXBoolLiteralExpr::Create(ast, value, qt.getUnqualifiedType(),
                                           SourceLocation()));
 }
 
 void TypeSystemClang::SetIntegerInitializerForVariable(

lldb/test/API/lang/cpp/const_static_integral_member/TestConstStaticIntegralMember.py

def test(self):
         self.expect_expr("A::long_min == long_min", result_value="true")
         self.expect_expr("A::ulong_min == ulong_min", result_value="true")
         self.expect_expr("A::longlong_min == longlong_min", result_value="true")
         self.expect_expr("A::ulonglong_min == ulonglong_min", result_value="true")
         self.expect_expr("A::wchar_min == wchar_min", result_value="true")
 
         # Test an unscoped enum.
         self.expect_expr("A::enum_val", result_value="enum_case2")
+        # Test an unscoped enum with bool as the underlying type.
+        self.expect_expr("A::enum_bool_val", result_value="enum_bool_case2")
 
         # Test a scoped enum.
         self.expect_expr("A::scoped_enum_val", result_value="scoped_enum_case2")
         # Test an scoped enum with a value that isn't an enumerator.
         self.expect_expr("A::not_enumerator_scoped_enum_val", result_value="scoped_enum_case1 | 0x4")
         # This time with more than one enum value plus the extra.
         self.expect_expr("A::not_enumerator_scoped_enum_val_2",
                          result_value="scoped_enum_case1 | scoped_enum_case2 | 0x4")

lldb/test/API/lang/cpp/const_static_integral_member/main.cpp

 #include <limits>
 
 enum Enum {
   enum_case1 = 1,
   enum_case2 = 2,
 };
 
+enum EnumBool : bool {
+  enum_bool_case1 = false,
+  enum_bool_case2 = true,
+};
+
 enum class ScopedEnum {
   scoped_enum_case1 = 1,
   scoped_enum_case2 = 2,
 };
 
 enum class ScopedCharEnum : char {
   case1 = 1,
   case2 = 2,
struct A {
   const static auto long_min = std::numeric_limits<long>::min();
   const static auto ulong_min = std::numeric_limits<unsigned long>::min();
   const static auto longlong_min = std::numeric_limits<long long>::min();
   const static auto ulonglong_min =
       std::numeric_limits<unsigned long long>::min();
   const static auto wchar_min = std::numeric_limits<wchar_t>::min();
 
   const static Enum enum_val = enum_case2;
+  const static EnumBool enum_bool_val = enum_bool_case2;
   const static ScopedEnum scoped_enum_val = ScopedEnum::scoped_enum_case2;
   const static ScopedEnum not_enumerator_scoped_enum_val = static_cast<ScopedEnum>(5);
   const static ScopedEnum not_enumerator_scoped_enum_val_2 =
       static_cast<ScopedEnum>(7);
   const static ScopedCharEnum scoped_char_enum_val = ScopedCharEnum::case2;
   const static ScopedLongLongEnum scoped_ll_enum_val_neg =
       ScopedLongLongEnum::case0;
   const static ScopedLongLongEnum scoped_ll_enum_val =