Reflection: Decode imported Objective-C classes and protocols as their own TypeRef

Right now we expect that every class and protocol has a field
descriptor that tells us if the entity is @objc or not.

For imported types, the descriptor will not exist if we did not
directly emit a field whose concrete type contains the imported
type. For example, in lldb, we might have a generic type whose
runtime substituted type includes an imported type.

In this case, TypeLowering would fail to produce a layout because
it did not find a field descriptor for the imported type.

A better approach is to have the TypeDecoder call a different
factory method for imported types, and handle them specially in
TypeLowering, bypassing the field type metadata altogether.

Author: slavapestov

include/swift/Demangling/TypeDecoder.h

@@ -22,6 +22,7 @@
 #include "swift/Demangling/Demangler.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Runtime/Unreachable.h"
+#include "swift/Strings.h"
 #include <vector>
 
 namespace swift {
@@ -75,6 +76,34 @@ class FunctionParam {
   }
 };
 
+
+#if SWIFT_OBJC_INTEROP
+/// For a mangled node that refers to an Objective-C class or protocol,
+/// return the class or protocol name.
+static inline Optional<StringRef> getObjCClassOrProtocolName(
+    const Demangle::NodePointer &node) {
+  if (node->getKind() != Demangle::Node::Kind::Class &&
+      node->getKind() != Demangle::Node::Kind::Protocol)
+    return None;
+
+  if (node->getNumChildren() != 2)
+    return None;
+
+  // Check whether we have the __ObjC module.
+  auto moduleNode = node->getChild(0);
+  if (moduleNode->getKind() != Demangle::Node::Kind::Module ||
+      moduleNode->getText() != MANGLING_MODULE_OBJC)
+    return None;
+
+  // Check whether we have an identifier.
+  auto nameNode = node->getChild(1);
+  if (nameNode->getKind() != Demangle::Node::Kind::Identifier)
+    return None;
+
+  return nameNode->getText();
+}
+#endif
+
 /// Decode a mangled type to construct an abstract type, forming such
 /// types by invoking a custom builder.
 template <typename BuilderType>
@@ -112,6 +141,13 @@ class TypeDecoder {
 
       return decodeMangledType(Node->getChild(0));
     case NodeKind::Class:
+    {
+#if SWIFT_OBJC_INTEROP
+      if (auto mangledName = getObjCClassOrProtocolName(Node))
+        return Builder.createObjCClassType(mangledName->str());
+#endif
+      LLVM_FALLTHROUGH;
+    }
     case NodeKind::Enum:
     case NodeKind::Structure:
     case NodeKind::TypeAlias: // This can show up for imported Clang decls.
@@ -125,6 +161,14 @@ class TypeDecoder {
       return Builder.createNominalType(typeDecl, parent);
     }
     case NodeKind::BoundGenericClass:
+    {
+#if SWIFT_OBJC_INTEROP
+      if (Node->getNumChildren() == 2)
+        if (auto mangledName = getObjCClassOrProtocolName(Node->getChild(0)))
+          return Builder.createObjCClassType(mangledName->str());
+#endif
+      LLVM_FALLTHROUGH;
+    }
     case NodeKind::BoundGenericEnum:
     case NodeKind::BoundGenericStructure:
     case NodeKind::BoundGenericOtherNominalType: {
@@ -528,6 +572,11 @@ class TypeDecoder {
         && node->getKind() != NodeKind::ProtocolSymbolicReference)
       return BuiltProtocolDecl();
 
+#if SWIFT_OBJC_INTEROP
+    if (auto objcProtocolName = getObjCClassOrProtocolName(node))
+      return Builder.createObjCProtocolDecl(objcProtocolName->str());
+#endif
+
     return Builder.createProtocolDecl(node);
   }
 

include/swift/Reflection/TypeRef.h

@@ -386,11 +386,11 @@ class FunctionTypeRef final : public TypeRef {
 };
 
 class ProtocolCompositionTypeRef final : public TypeRef {
-  std::vector<const NominalTypeRef *> Protocols;
+  std::vector<const TypeRef *> Protocols;
   const TypeRef *Superclass;
   bool HasExplicitAnyObject;
 
-  static TypeRefID Profile(std::vector<const NominalTypeRef *> Protocols,
+  static TypeRefID Profile(std::vector<const TypeRef *> Protocols,
                            const TypeRef *Superclass,
                            bool HasExplicitAnyObject) {
     TypeRefID ID;
@@ -403,7 +403,7 @@ class ProtocolCompositionTypeRef final : public TypeRef {
   }
 
 public:
-  ProtocolCompositionTypeRef(std::vector<const NominalTypeRef *> Protocols,
+  ProtocolCompositionTypeRef(std::vector<const TypeRef *> Protocols,
                              const TypeRef *Superclass,
                              bool HasExplicitAnyObject)
     : TypeRef(TypeRefKind::ProtocolComposition),
@@ -412,13 +412,14 @@ class ProtocolCompositionTypeRef final : public TypeRef {
 
   template <typename Allocator>
   static const ProtocolCompositionTypeRef *
-  create(Allocator &A, std::vector<const NominalTypeRef *> Protocols,
+  create(Allocator &A, std::vector<const TypeRef *> Protocols,
          const TypeRef *Superclass, bool HasExplicitAnyObject) {
     FIND_OR_CREATE_TYPEREF(A, ProtocolCompositionTypeRef, Protocols,
                            Superclass, HasExplicitAnyObject);
   }
 
-  const std::vector<const NominalTypeRef *> &getProtocols() const {
+  // These are either NominalTypeRef or ObjCProtocolTypeRef.
+  const std::vector<const TypeRef *> &getProtocols() const {
     return Protocols;
   }
 
@@ -633,6 +634,36 @@ class ObjCClassTypeRef final : public TypeRef {
   }
 };
 
+class ObjCProtocolTypeRef final : public TypeRef {
+  std::string Name;
+  static const ObjCProtocolTypeRef *UnnamedSingleton;
+
+  static TypeRefID Profile(const std::string &Name) {
+    TypeRefID ID;
+    ID.addString(Name);
+    return ID;
+  }
+public:
+  ObjCProtocolTypeRef(const std::string &Name)
+    : TypeRef(TypeRefKind::ObjCProtocol), Name(Name) {}
+
+  static const ObjCProtocolTypeRef *getUnnamed();
+
+  template <typename Allocator>
+  static const ObjCProtocolTypeRef *create(Allocator &A,
+                                           const std::string &Name) {
+    FIND_OR_CREATE_TYPEREF(A, ObjCProtocolTypeRef, Name);
+  }
+
+  const std::string &getName() const {
+    return Name;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::ObjCProtocol;
+  }
+};
+
 class OpaqueTypeRef final : public TypeRef {
   static const OpaqueTypeRef *Singleton;
 

include/swift/Reflection/TypeRefBuilder.h

@@ -160,7 +160,7 @@ class TypeRefBuilder {
 public:
   using BuiltType = const TypeRef *;
   using BuiltNominalTypeDecl = Optional<std::string>;
-  using BuiltProtocolDecl = Optional<std::string>;
+  using BuiltProtocolDecl = Optional<std::pair<std::string, bool /*isObjC*/>>;
 
   TypeRefBuilder();
 
@@ -214,9 +214,14 @@ class TypeRefBuilder {
     return Demangle::mangleNode(node);
   }
 
-  Optional<std::string>
+  BuiltProtocolDecl
   createProtocolDecl(const Demangle::NodePointer &node) {
-    return Demangle::mangleNode(node);
+    return std::make_pair(Demangle::mangleNode(node), false);
+  }
+
+  BuiltProtocolDecl
+  createObjCProtocolDecl(std::string &&name) {
+    return std::make_pair(name, true);
   }
 
   Optional<std::string> createNominalTypeDecl(std::string &&mangledName) {
@@ -265,9 +270,15 @@ class TypeRefBuilder {
   createProtocolCompositionType(ArrayRef<BuiltProtocolDecl> protocols,
                                 BuiltType superclass,
                                 bool isClassBound) {
-    std::vector<const NominalTypeRef *> protocolRefs;
+    std::vector<const TypeRef *> protocolRefs;
     for (const auto &protocol : protocols) {
-      protocolRefs.push_back(createNominalType(protocol));
+      if (!protocol)
+        continue;
+
+      if (protocol->second)
+        protocolRefs.push_back(createObjCProtocolType(protocol->first));
+      else
+        protocolRefs.push_back(createNominalType(protocol->first));
     }
 
     return ProtocolCompositionTypeRef::create(*this, protocolRefs, superclass,
@@ -292,8 +303,12 @@ class TypeRefBuilder {
   const DependentMemberTypeRef *
   createDependentMemberType(const std::string &member,
                             const TypeRef *base,
-                            Optional<std::string> protocol) {
-    return DependentMemberTypeRef::create(*this, member, base, *protocol);
+                            BuiltProtocolDecl protocol) {
+    // Objective-C protocols don't have dependent types.
+    if (protocol->second)
+      return nullptr;
+    return DependentMemberTypeRef::create(*this, member, base,
+                                          protocol->first);
   }
 
 #define REF_STORAGE(Name, ...) \
@@ -306,13 +321,18 @@ class TypeRefBuilder {
     return SILBoxTypeRef::create(*this, base);
   }
 
+  const ObjCClassTypeRef *getUnnamedObjCClassType() {
+    return createObjCClassType("");
+  }
+
   const ObjCClassTypeRef *
-  createObjCClassType(const std::string &mangledName) {
-    return ObjCClassTypeRef::create(*this, mangledName);
+  createObjCClassType(const std::string &name) {
+    return ObjCClassTypeRef::create(*this, name);
   }
 
-  const ObjCClassTypeRef *getUnnamedObjCClassType() {
-    return createObjCClassType("");
+  const ObjCProtocolTypeRef *
+  createObjCProtocolType(const std::string &name) {
+    return ObjCProtocolTypeRef::create(*this, name);
   }
 
   const ForeignClassTypeRef *

include/swift/Reflection/TypeRefs.def

@@ -28,6 +28,7 @@ TYPEREF(GenericTypeParameter, TypeRef)
 TYPEREF(DependentMember, TypeRef)
 TYPEREF(ForeignClass, TypeRef)
 TYPEREF(ObjCClass, TypeRef)
+TYPEREF(ObjCProtocol, TypeRef)
 TYPEREF(Opaque, TypeRef)
 #define REF_STORAGE(Name, ...) \
   TYPEREF(Name##Storage, TypeRef)

include/swift/Remote/MetadataReader.h

@@ -509,6 +509,8 @@ class MetadataReader {
           if (!Demangled)
             return BuiltType();
 
+          // FIXME: Imported protocols?
+
           auto Protocol = Builder.createProtocolDecl(Demangled);
           if (!Protocol)
             return BuiltType();

lib/RemoteAST/RemoteAST.cpp

@@ -438,6 +438,16 @@ class RemoteASTTypeBuilder {
     return createNominalType(typeDecl, /*parent*/ Type());
   }
 
+  ProtocolDecl *createObjCProtocolDecl(StringRef name) {
+    auto typeDecl =
+        findForeignNominalTypeDecl(name, /*relatedEntityKind*/{},
+                                   ForeignModuleKind::Imported,
+                                   Demangle::Node::Kind::Protocol);
+    if (auto *protocolDecl = dyn_cast_or_null<ProtocolDecl>(typeDecl))
+      return protocolDecl;
+    return nullptr;
+  }
+
   Type createForeignClassType(StringRef mangledName) {
     auto typeDecl = createNominalTypeDecl(mangledName);
     if (!typeDecl) return Type();

stdlib/public/Reflection/TypeLowering.cpp

@@ -197,7 +197,7 @@ BuiltinTypeInfo::BuiltinTypeInfo(const BuiltinTypeDescriptor *descriptor)
 /// Utility class for building values that contain witness tables.
 class ExistentialTypeInfoBuilder {
   TypeConverter &TC;
-  std::vector<const NominalTypeRef *> Protocols;
+  std::vector<const TypeRef *> Protocols;
   const TypeRef *Superclass = nullptr;
   ExistentialTypeRepresentation Representation;
   ReferenceCounting Refcounting;
@@ -218,8 +218,9 @@ class ExistentialTypeInfoBuilder {
       return false;
 
     for (auto *P : Protocols) {
-      if (P->isErrorProtocol())
-        return true;
+      if (auto *NTD = dyn_cast<NominalTypeRef>(P))
+        if (NTD->isErrorProtocol())
+          return true;
     }
     return false;
   }
@@ -232,6 +233,20 @@ class ExistentialTypeInfoBuilder {
     }
 
     for (auto *P : Protocols) {
+      auto *NTD = dyn_cast<NominalTypeRef>(P);
+      auto *OP = dyn_cast<ObjCProtocolTypeRef>(P);
+      if (!NTD && !OP) {
+        DEBUG_LOG(std::cerr << "Bad protocol: "; P->dump())
+        Invalid = true;
+        continue;
+      }
+
+      // Don't look up field info for imported Objective-C protocols.
+      if (OP) {
+        ObjC = true;
+        continue;
+      }
+
       std::pair<const FieldDescriptor *, const ReflectionInfo *> FD =
           TC.getBuilder().getFieldTypeInfo(P);
       if (FD.first == nullptr) {
@@ -270,7 +285,7 @@ class ExistentialTypeInfoBuilder {
       ObjC(false), WitnessTableCount(0),
       Invalid(false) {}
 
-  void addProtocol(const NominalTypeRef *P) {
+  void addProtocol(const TypeRef *P) {
     Protocols.push_back(P);
   }
 
@@ -286,11 +301,19 @@ class ExistentialTypeInfoBuilder {
       // Anything else should either be a superclass constraint, or
       // we have an invalid typeref.
       if (!isa<NominalTypeRef>(T) &&
-          !isa<BoundGenericTypeRef>(T)) {
+          !isa<BoundGenericTypeRef>(T) &&
+          !isa<ObjCClassTypeRef>(T)) {
         DEBUG_LOG(std::cerr << "Bad existential member: "; T->dump())
         Invalid = true;
         return;
       }
+
+      // Don't look up field info for imported Objective-C classes.
+      if (auto *OC = dyn_cast<ObjCClassTypeRef>(T)) {
+        addAnyObject();
+        return;
+      }
+
       const auto &FD = TC.getBuilder().getFieldTypeInfo(T);
       if (FD.first == nullptr) {
         DEBUG_LOG(std::cerr << "No field descriptor: "; T->dump())
@@ -721,6 +744,10 @@ class HasFixedSize
     return true;
   }
 
+  bool visitObjCProtocolTypeRef(const ObjCProtocolTypeRef *OP) {
+    return true;
+  }
+
 #define REF_STORAGE(Name, ...) \
   bool \
   visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
@@ -848,6 +875,10 @@ class HasSingletonMetatype
     return MetatypeRepresentation::Unknown;
   }
 
+  MetatypeRepresentation visitObjCProtocolTypeRef(const ObjCProtocolTypeRef *OP) {
+    return MetatypeRepresentation::Unknown;
+  }
+
 #define REF_STORAGE(Name, ...) \
   MetatypeRepresentation \
   visit##Name##StorageTypeRef(const Name##StorageTypeRef *US) { \
@@ -1197,6 +1228,11 @@ class LowerType
                                    ReferenceCounting::Unknown);
   }
 
+  const TypeInfo *visitObjCProtocolTypeRef(const ObjCProtocolTypeRef *OP) {
+    return TC.getReferenceTypeInfo(ReferenceKind::Strong,
+                                   ReferenceCounting::Unknown);
+  }
+
   // Apply a storage qualifier, like 'weak', 'unowned' or 'unowned(unsafe)'
   // to a type with reference semantics, such as a class reference or
   // class-bound existential.