[lldb][TypeSystem] Call Type::isIntegralType from TypeSystemClang::IsIntegerType (#175669)

Instead of re-implementing `Type::isIntegralType`, call it explicitly.

This means we get support for `BitIntType` out-of-the-box.

We don't use `IsIntegerType` here because we want to abide by the
language-specific notions of an integer type (which differ between C++
and C).

The slight behaviour change here is that `IsIntegerType` will now treat
complete enumerations as integers in C. This is correct according to the
C standard.

Author: Michael137

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

@@ -3290,17 +3290,18 @@ bool TypeSystemClang::IsIntegerType(lldb::opaque_compiler_type_t type,
     return false;
 
   clang::QualType qual_type(GetCanonicalQualType(type));
-  const clang::BuiltinType *builtin_type =
-      llvm::dyn_cast<clang::BuiltinType>(qual_type->getCanonicalTypeInternal());
+  if (qual_type.isNull())
+    return false;
 
-  if (builtin_type) {
-    if (builtin_type->isInteger()) {
-      is_signed = builtin_type->isSignedInteger();
-      return true;
-    }
-  }
+  // Note, using 'isIntegralType' as opposed to 'isIntegerType' because
+  // the latter treats unscoped enums as integer types (which is not true
+  // in C++). The former accounts for this.
+  if (!qual_type->isIntegralType(getASTContext()))
+    return false;
 
-  return false;
+  is_signed = qual_type->isSignedIntegerType();
+
+  return true;
 }
 
 bool TypeSystemClang::IsEnumerationType(lldb::opaque_compiler_type_t type,

lldb/unittests/Symbol/TestTypeSystemClang.cpp

@@ -436,6 +436,7 @@ TEST_F(TestTypeSystemClang, TestIsEnumerationType) {
     bool is_signed;
     EXPECT_TRUE(enum_type.IsEnumerationType(is_signed));
     EXPECT_TRUE(is_signed);
+    EXPECT_FALSE(enum_type.IsIntegerType(is_signed));
   }
 
   // Scoped unsigned enum
@@ -449,6 +450,7 @@ TEST_F(TestTypeSystemClang, TestIsEnumerationType) {
     bool is_signed;
     EXPECT_TRUE(enum_type.IsEnumerationType(is_signed));
     EXPECT_FALSE(is_signed);
+    EXPECT_FALSE(enum_type.IsIntegerType(is_signed));
   }
 
   // Unscoped signed enum
@@ -462,6 +464,7 @@ TEST_F(TestTypeSystemClang, TestIsEnumerationType) {
     bool is_signed;
     EXPECT_TRUE(enum_type.IsEnumerationType(is_signed));
     EXPECT_TRUE(is_signed);
+    EXPECT_FALSE(enum_type.IsIntegerType(is_signed));
   }
 
   // Unscoped unsigned enum
@@ -475,6 +478,47 @@ TEST_F(TestTypeSystemClang, TestIsEnumerationType) {
     bool is_signed;
     EXPECT_TRUE(enum_type.IsEnumerationType(is_signed));
     EXPECT_FALSE(is_signed);
+    EXPECT_FALSE(enum_type.IsIntegerType(is_signed));
+  }
+}
+
+TEST_F(TestTypeSystemClang, TestIsIntegerType_BitInt) {
+  auto holder =
+      std::make_unique<clang_utils::TypeSystemClangHolder>("bitint_ast");
+  auto &ast = *holder->GetAST();
+
+  // Signed _BitInt
+  {
+    CompilerType bitint_type = ast.GetType(
+        ast.getASTContext().getBitIntType(/*Unsigned=*/false, /*NumBits=*/37));
+    ASSERT_TRUE(bitint_type);
+
+    EXPECT_TRUE(bitint_type.IsInteger());
+    EXPECT_TRUE(bitint_type.IsSigned());
+
+    bool is_signed;
+    EXPECT_TRUE(bitint_type.IsIntegerType(is_signed));
+    EXPECT_TRUE(is_signed);
+
+    EXPECT_TRUE(bitint_type.IsIntegerOrEnumerationType(is_signed));
+    EXPECT_TRUE(is_signed);
+  }
+
+  // Unsigned _BitInt
+  {
+    CompilerType bitint_type = ast.GetType(
+        ast.getASTContext().getBitIntType(/*Unsigned=*/true, /*NumBits=*/122));
+    ASSERT_TRUE(bitint_type);
+
+    EXPECT_TRUE(bitint_type.IsInteger());
+    EXPECT_FALSE(bitint_type.IsSigned());
+
+    bool is_signed;
+    EXPECT_TRUE(bitint_type.IsIntegerType(is_signed));
+    EXPECT_FALSE(is_signed);
+
+    EXPECT_TRUE(bitint_type.IsIntegerOrEnumerationType(is_signed));
+    EXPECT_FALSE(is_signed);
   }
 }