Implement TypeSystemSwiftTypeRef::GetTypeClass (NFC)

and add a unit test for it.

Author: adrian-prantl

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

@@ -755,7 +755,7 @@ static uint32_t collectTypeInfo(Module *M, swift::Demangle::Demangler &Dem,
         else if (node->getText() == swift::BUILTIN_TYPE_NAME_BRIDGEOBJECT)
           swift_flags |=
               eTypeHasChildren | eTypeIsPointer | eTypeIsScalar | eTypeIsObjC;
-        else if (node->getText() == swift::BUILTIN_TYPE_NAME_VEC)
+        else if (node->getText().startswith(swift::BUILTIN_TYPE_NAME_VEC))
           swift_flags |= eTypeHasChildren | eTypeIsVector;
       }
       break;
@@ -1461,7 +1461,31 @@ uint32_t TypeSystemSwiftTypeRef::GetTypeInfo(
 }
 lldb::TypeClass
 TypeSystemSwiftTypeRef::GetTypeClass(opaque_compiler_type_t type) {
-  return m_swift_ast_context->GetTypeClass(ReconstructType(type));
+  auto impl = [&]() {
+    uint32_t flags = GetTypeInfo(type, nullptr);
+    // The ordering is significant since GetTypeInfo() returns many flags.
+    if ((flags & eTypeIsScalar))
+      return eTypeClassBuiltin;
+    if ((flags & eTypeIsVector))
+      return eTypeClassVector;
+    if ((flags & eTypeIsTuple))
+      return eTypeClassArray;
+    if ((flags & eTypeIsEnumeration))
+      return eTypeClassUnion;
+    if ((flags & eTypeIsProtocol))
+      return eTypeClassOther;
+    if ((flags & eTypeIsStructUnion))
+      return eTypeClassStruct;
+    if ((flags & eTypeIsClass))
+      return eTypeClassClass;
+    if ((flags & eTypeIsReference))
+      return eTypeClassReference;
+    // This only works because we excluded all other options.
+    if ((flags & eTypeIsPointer))
+      return eTypeClassFunction;
+    return eTypeClassOther;
+  };
+  VALIDATE_AND_RETURN(impl, GetTypeClass, type, (ReconstructType(type)));
 }
 
 // Creating related types

lldb/unittests/Symbol/TestTypeSystemSwiftTypeRef.cpp

@@ -357,3 +357,77 @@ TEST_F(TestTypeSystemSwiftTypeRef, LanguageVersion) {
     ASSERT_EQ(int_type.GetMinimumLanguage(), lldb::eLanguageTypeSwift);
   }
 }
+
+TEST_F(TestTypeSystemSwiftTypeRef, TypeClass) {
+  using namespace swift::Demangle;
+  Demangler dem;
+  NodeBuilder b(dem);
+  {
+    NodePointer n = b.GlobalTypeMangling(b.IntType());
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassBuiltin);
+  }
+  {
+    std::string vec = StringRef(swift::BUILTIN_TYPE_NAME_VEC).str() + "4xInt8";
+    NodePointer n =
+        b.GlobalType(b.Node(Node::Kind::BuiltinTypeName, vec.c_str()));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassVector);
+  }
+  {
+    NodePointer n = b.GlobalType(b.Node(Node::Kind::Tuple));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassArray);
+  }
+  {
+    NodePointer n =
+        b.GlobalType(b.Node(Node::Kind::Enum, b.Node(Node::Kind::Module, "M"),
+                            b.Node(Node::Kind::Identifier, "E")));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassUnion);
+  }
+  {
+    NodePointer n = b.GlobalType(b.Node(Node::Kind::Structure,
+                                        b.Node(Node::Kind::Module, "M"),
+                                        b.Node(Node::Kind::Identifier, "S")));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassStruct);
+  }
+  {
+    NodePointer n =
+        b.GlobalType(b.Node(Node::Kind::Class, b.Node(Node::Kind::Module, "M"),
+                            b.Node(Node::Kind::Identifier, "C")));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassClass);
+  }
+  {
+    NodePointer n = b.GlobalType(b.Node(
+        Node::Kind::InOut,
+        b.Node(Node::Kind::Structure,
+               b.Node(Node::Kind::Module, swift::STDLIB_NAME),
+               b.Node(Node::Kind::Identifier, swift::BUILTIN_TYPE_NAME_INT))));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassReference);
+  }
+  {
+    NodePointer n = b.GlobalType(
+        b.Node(Node::Kind::FunctionType,
+               b.Node(Node::Kind::ArgumentTuple,
+                      b.Node(Node::Kind::Type, b.Node(Node::Kind::Tuple))),
+               b.Node(Node::Kind::ReturnType,
+                      b.Node(Node::Kind::Type, b.Node(Node::Kind::Tuple)))));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassFunction);
+  }
+  {
+    NodePointer n = b.GlobalType(b.Node(
+        Node::Kind::ProtocolList,
+        b.Node(Node::Kind::TypeList,
+               b.Node(Node::Kind::Type,
+                      b.Node(Node::Kind::Protocol,
+                             b.Node(Node::Kind::Module, swift::STDLIB_NAME),
+                             b.Node(Node::Kind::Identifier, "Error"))))));
+    CompilerType t = GetCompilerType(b.Mangle(n));
+    ASSERT_EQ(t.GetTypeClass(), lldb::eTypeClassOther);
+  }
+}