[NFC][lldb] Use ASTContext::getPromotedIntegerType for integral promotion in DIL (llvm#191448)

Author: kuilpd

lldb/include/lldb/Symbol/CompilerType.h

@@ -226,6 +226,8 @@ class CompilerType {
 
   bool IsScalarOrUnscopedEnumerationType() const;
 
+  /// Checks if the type is eligible for integral promotion.
+  /// \see GetPromotedIntegerType
   bool IsPromotableIntegerType() const;
 
   bool IsPointerToVoid() const;
@@ -508,6 +510,11 @@ class CompilerType {
 
   CompilerType GetTypeForFormatters() const;
 
+  /// If the type is promotable, returns the type promoted to a larger
+  /// integer type according to the type system rules.
+  /// \see IsPromotableIntegerType
+  CompilerType GetPromotedIntegerType() const;
+
   LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;
 
   bool IsMeaninglessWithoutDynamicResolution() const;

lldb/include/lldb/Symbol/TypeSystem.h

@@ -418,17 +418,10 @@ class TypeSystem : public PluginInterface,
   GetIntegralTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
                               bool expand_pack);
 
-  // DIL
-
-  /// Checks if the type is eligible for integral promotion.
   virtual bool IsPromotableIntegerType(lldb::opaque_compiler_type_t type);
 
-  /// Perform integral promotion on a given type.
-  /// This promotes eligible types (boolean, integers, unscoped enumerations)
-  /// to a larger integer type according to type system rules.
-  /// \returns Promoted type.
-  virtual llvm::Expected<CompilerType>
-  DoIntegralPromotion(CompilerType from, ExecutionContextScope *exe_scope);
+  virtual CompilerType
+  GetPromotedIntegerType(lldb::opaque_compiler_type_t type);
 
   // Dumping types
 

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

@@ -7269,98 +7269,16 @@ CompilerType TypeSystemClang::GetTypeForFormatters(void *type) {
 
 bool TypeSystemClang::IsPromotableIntegerType(
     lldb::opaque_compiler_type_t type) {
-  // Unscoped enums are always considered as promotable, even if their
-  // underlying type does not need to be promoted (e.g. "int").
-  bool is_signed = false;
-  bool isUnscopedEnumerationType =
-      IsEnumerationType(type, is_signed) && !IsScopedEnumerationType(type);
-  if (isUnscopedEnumerationType)
-    return true;
-
-  switch (GetBasicTypeEnumeration(type)) {
-  case lldb::eBasicTypeBool:
-  case lldb::eBasicTypeChar:
-  case lldb::eBasicTypeSignedChar:
-  case lldb::eBasicTypeUnsignedChar:
-  case lldb::eBasicTypeShort:
-  case lldb::eBasicTypeUnsignedShort:
-  case lldb::eBasicTypeWChar:
-  case lldb::eBasicTypeSignedWChar:
-  case lldb::eBasicTypeUnsignedWChar:
-  case lldb::eBasicTypeChar16:
-  case lldb::eBasicTypeChar32:
-    return true;
-
-  default:
-    return false;
-  }
-
-  llvm_unreachable("All cases handled above.");
+  clang::QualType qual_type(GetCanonicalQualType(type));
+  return getASTContext().isPromotableIntegerType(qual_type);
 }
 
-llvm::Expected<CompilerType>
-TypeSystemClang::DoIntegralPromotion(CompilerType from,
-                                     ExecutionContextScope *exe_scope) {
-  if (!from.IsInteger() && !from.IsUnscopedEnumerationType())
-    return from;
-
-  if (!from.IsPromotableIntegerType())
-    return from;
-
-  if (from.IsUnscopedEnumerationType()) {
-    EnumDecl *enum_decl = GetAsEnumDecl(from);
-    CompilerType promotion_type = GetType(enum_decl->getPromotionType());
-    return DoIntegralPromotion(promotion_type, exe_scope);
-  }
-
-  lldb::BasicType builtin_type =
-      from.GetCanonicalType().GetBasicTypeEnumeration();
-  uint64_t from_size = 0;
-  if (builtin_type == lldb::eBasicTypeWChar ||
-      builtin_type == lldb::eBasicTypeSignedWChar ||
-      builtin_type == lldb::eBasicTypeUnsignedWChar ||
-      builtin_type == lldb::eBasicTypeChar16 ||
-      builtin_type == lldb::eBasicTypeChar32) {
-    // Find the type that can hold the entire range of values for our type.
-    bool is_signed = from.IsSigned();
-    llvm::Expected<uint64_t> from_size = from.GetByteSize(exe_scope);
-    if (!from_size)
-      return from_size.takeError();
-    CompilerType promote_types[] = {
-        GetBasicTypeFromAST(lldb::eBasicTypeInt),
-        GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt),
-        GetBasicTypeFromAST(lldb::eBasicTypeLong),
-        GetBasicTypeFromAST(lldb::eBasicTypeUnsignedLong),
-        GetBasicTypeFromAST(lldb::eBasicTypeLongLong),
-        GetBasicTypeFromAST(lldb::eBasicTypeUnsignedLongLong),
-    };
-    for (CompilerType &type : promote_types) {
-      llvm::Expected<uint64_t> byte_size = type.GetByteSize(exe_scope);
-      if (!byte_size)
-        return byte_size.takeError();
-      if (*from_size < *byte_size ||
-          (*from_size == *byte_size && is_signed == type.IsSigned())) {
-        return type;
-      }
-    }
-    llvm_unreachable("char type should fit into long long");
-  }
-
-  // Here we can promote only to "int" or "unsigned int".
-  CompilerType int_type = GetBasicTypeFromAST(lldb::eBasicTypeInt);
-  llvm::Expected<uint64_t> int_byte_size = int_type.GetByteSize(exe_scope);
-  if (!int_byte_size)
-    return int_byte_size.takeError();
-
-  // Signed integer types can be safely promoted to "int".
-  if (from.IsSigned()) {
-    return int_type;
-  }
-  // Unsigned integer types are promoted to "unsigned int" if "int" cannot hold
-  // their entire value range.
-  return (from_size == *int_byte_size)
-             ? GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt)
-             : int_type;
+CompilerType
+TypeSystemClang::GetPromotedIntegerType(lldb::opaque_compiler_type_t type) {
+  if (!IsPromotableIntegerType(type))
+    return CompilerType();
+  clang::QualType qual_type(GetCanonicalQualType(type));
+  return GetType(getASTContext().getPromotedIntegerType(qual_type));
 }
 
 clang::EnumDecl *TypeSystemClang::GetAsEnumDecl(const CompilerType &type) {

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

@@ -941,13 +941,10 @@ class TypeSystemClang : public TypeSystem {
 
   CompilerType GetTypeForFormatters(void *type) override;
 
-  // DIL
-
   bool IsPromotableIntegerType(lldb::opaque_compiler_type_t type) override;
 
-  llvm::Expected<CompilerType>
-  DoIntegralPromotion(CompilerType from,
-                      ExecutionContextScope *exe_scope) override;
+  CompilerType
+  GetPromotedIntegerType(lldb::opaque_compiler_type_t type) override;
 
 #define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   // LLDB_INVALID_DECL_LEVEL is returned by CountDeclLevels if child_decl_ctx

lldb/source/Symbol/CompilerType.cpp

@@ -1010,6 +1010,13 @@ CompilerType CompilerType::GetTypeForFormatters() const {
   return CompilerType();
 }
 
+CompilerType CompilerType::GetPromotedIntegerType() const {
+  if (IsValid())
+    if (auto type_system_sp = GetTypeSystem())
+      return type_system_sp->GetPromotedIntegerType(m_type);
+  return CompilerType();
+}
+
 LazyBool CompilerType::ShouldPrintAsOneLiner(ValueObject *valobj) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())

lldb/source/Symbol/TypeSystem.cpp

@@ -123,11 +123,9 @@ bool TypeSystem::IsPromotableIntegerType(lldb::opaque_compiler_type_t type) {
   return false;
 }
 
-llvm::Expected<CompilerType>
-TypeSystem::DoIntegralPromotion(CompilerType from,
-                                ExecutionContextScope *exe_scope) {
-  return llvm::createStringError(
-      "Integral promotion is not implemented for this TypeSystem");
+CompilerType
+TypeSystem::GetPromotedIntegerType(lldb::opaque_compiler_type_t type) {
+  return CompilerType();
 }
 
 bool TypeSystem::IsTemplateType(lldb::opaque_compiler_type_t type) {

lldb/source/ValueObject/DILEval.cpp

@@ -113,16 +113,10 @@ Interpreter::UnaryConversion(lldb::ValueObjectSP valobj, uint32_t location) {
   if (in_type.IsArrayType())
     valobj = ArrayToPointerConversion(*valobj, *m_exe_ctx_scope, "result");
 
-  if (valobj->GetCompilerType().IsInteger() ||
-      valobj->GetCompilerType().IsUnscopedEnumerationType()) {
-    llvm::Expected<CompilerType> promoted_type =
-        type_system.get()->DoIntegralPromotion(valobj->GetCompilerType(),
-                                               m_exe_ctx_scope.get());
-    if (!promoted_type)
-      return promoted_type.takeError();
-    if (!promoted_type->CompareTypes(valobj->GetCompilerType()))
-      return valobj->CastToBasicType(*promoted_type);
-  }
+  CompilerType promoted_type =
+      valobj->GetCompilerType().GetPromotedIntegerType();
+  if (promoted_type)
+    return valobj->CastToBasicType(promoted_type);
 
   return valobj;
 }