Hoist SwiftASTContext::IsFloatingPointType into TypeSystemSwift (NFC)

and add a unit test for it.

Author: adrian-prantl

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -5156,20 +5156,6 @@ bool SwiftASTContext::IsReferenceType(opaque_compiler_type_t type,
   return false;
 }
 
-bool SwiftASTContext::IsFloatingPointType(opaque_compiler_type_t type,
-                                          uint32_t &count, bool &is_complex) {
-  if (type) {
-    if (GetTypeInfo(type, nullptr) & eTypeIsFloat) {
-      count = 1;
-      is_complex = false;
-      return true;
-    }
-  }
-  count = 0;
-  is_complex = false;
-  return false;
-}
-
 bool SwiftASTContext::IsDefined(opaque_compiler_type_t type) {
   if (!type)
     return false;

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -455,9 +455,6 @@ class SwiftASTContext : public TypeSystemSwift {
 
   bool IsDefined(lldb::opaque_compiler_type_t type) override;
 
-  bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
-                           bool &is_complex) override;
-
   bool IsFunctionType(lldb::opaque_compiler_type_t type,
                       bool *is_variadic_ptr) override;
 

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwift.cpp

@@ -11,3 +11,18 @@
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/TypeSystem/Swift/TypeSystemSwift.h"
+#include <lldb/lldb-enumerations.h>
+
+using namespace lldb;
+using namespace lldb_private;
+
+bool TypeSystemSwift::IsFloatingPointType(opaque_compiler_type_t type,
+                                          uint32_t &count, bool &is_complex) {
+  count = 0;
+  is_complex = false;
+  if (GetTypeInfo(type, nullptr) & eTypeIsFloat) {
+    count = 1;
+    return true;
+  }
+  return false;
+}

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwift.h

@@ -132,6 +132,8 @@ class TypeSystemSwift : public TypeSystem {
     return true;
   }
   bool IsConst(lldb::opaque_compiler_type_t type) override { return false; }
+  bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
+                           bool &is_complex) override;
   bool IsCStringType(lldb::opaque_compiler_type_t type,
                      uint32_t &length) override {
     return false;

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp

@@ -1254,12 +1254,6 @@ bool TypeSystemSwiftTypeRef::IsDefined(opaque_compiler_type_t type) {
   auto impl = [&]() -> bool { return type; };
   VALIDATE_AND_RETURN(impl, IsDefined, type, (ReconstructType(type)));
 }
-bool TypeSystemSwiftTypeRef::IsFloatingPointType(opaque_compiler_type_t type,
-                                                 uint32_t &count,
-                                                 bool &is_complex) {
-  return m_swift_ast_context->IsFloatingPointType(ReconstructType(type), count,
-                                                  is_complex);
-}
 
 bool TypeSystemSwiftTypeRef::IsFunctionType(opaque_compiler_type_t type,
                                             bool *is_variadic_ptr) {

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h

@@ -88,8 +88,6 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
                    bool *is_incomplete) override;
   bool IsAggregateType(lldb::opaque_compiler_type_t type) override;
   bool IsDefined(lldb::opaque_compiler_type_t type) override;
-  bool IsFloatingPointType(lldb::opaque_compiler_type_t type, uint32_t &count,
-                           bool &is_complex) override;
   bool IsFunctionType(lldb::opaque_compiler_type_t type,
                       bool *is_variadic_ptr) override;
   size_t

lldb/unittests/Symbol/TestTypeSystemSwiftTypeRef.cpp

@@ -69,6 +69,13 @@ class NodeBuilder {
              Node(Node::Kind::Module, swift::STDLIB_NAME),
              Node(Node::Kind::Identifier, swift::BUILTIN_TYPE_NAME_INT)));
   }
+  NodePointer FloatType() {
+    return Node(
+        Node::Kind::Type,
+        Node(Node::Kind::Structure,
+             Node(Node::Kind::Module, swift::STDLIB_NAME),
+             Node(Node::Kind::Identifier, swift::BUILTIN_TYPE_NAME_FLOAT)));
+  }
   NodePointer GlobalTypeMangling(NodePointer type) {
     assert(type && type->getKind() == Node::Kind::Type);
     return Node(Node::Kind::Global, Node(Node::Kind::TypeMangling, type));
@@ -281,3 +288,27 @@ TEST_F(TestTypeSystemSwiftTypeRef, Defined) {
     ASSERT_FALSE(m_swift_ts.IsDefined(nullptr));
   }
 }
+
+TEST_F(TestTypeSystemSwiftTypeRef, Float) {
+  using namespace swift::Demangle;
+  Demangler dem;
+  NodeBuilder b(dem);
+  {
+    NodePointer int_node = b.GlobalTypeMangling(b.IntType());
+    CompilerType int_type = GetCompilerType(b.Mangle(int_node));
+    uint32_t count = 99;
+    bool is_complex = true;
+    ASSERT_FALSE(int_type.IsFloatingPointType(count, is_complex));
+    ASSERT_EQ(count, 0);
+    ASSERT_EQ(is_complex, false);
+  }
+  {
+    NodePointer float_node = b.GlobalTypeMangling(b.FloatType());
+    CompilerType float_type = GetCompilerType(b.Mangle(float_node));
+    uint32_t count = 99;
+    bool is_complex = true;
+    ASSERT_TRUE(float_type.IsFloatingPointType(count, is_complex));
+    ASSERT_EQ(count, 1);
+    ASSERT_EQ(is_complex, false);
+  }
+}