Reflection: Add basic type lowering for existentials

This approach doesn't work for imported Objective-C protocols yet.

Author: slavapestov

include/swift/Reflection/TypeLowering.h

@@ -36,7 +36,18 @@ class TypeRefBuilder;
 enum class RecordKind : unsigned {
   Tuple,
   Struct,
+
+  // A Swift-native function is always a function pointer followed by a
+  // retainable, nullable context pointer.
   ThickFunction,
+
+  // An existential is a three-word buffer followed by value metadata and
+  // witness tables.
+  Existential,
+
+  // A class existential is a retainable pointer followed by witness
+  // tables.
+  ClassExistential,
 };
 
 enum class ReferenceCounting : unsigned {

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -38,16 +38,23 @@ typedef struct swift_reflection_section_t {
   void *End;
 } swift_reflection_section_t;
 
-/// The kind of a Swift type.
+/// The layout kind of a Swift type.
 typedef enum swift_layout_kind_t {
+  // Nothing is known about the size or contents of this value.
   SWIFT_UNKNOWN,
 
+  // An opaque value with known size and alignment but no specific
+  // interpretation.
   SWIFT_BUILTIN,
 
+  // Record types consisting of zero or more fields.
   SWIFT_TUPLE,
   SWIFT_STRUCT,
   SWIFT_THICK_FUNCTION,
+  SWIFT_EXISTENTIAL,
+  SWIFT_CLASS_EXISTENTIAL,
 
+  // References to other objects in the heap.
   SWIFT_STRONG_REFERENCE,
   SWIFT_UNOWNED_REFERENCE,
   SWIFT_WEAK_REFERENCE,
@@ -58,7 +65,7 @@ struct swift_childinfo;
 
 /// A description of the memory layout of a type or field of a type.
 typedef struct swift_typeinfo {
-  swift_layout_kind_t LayoutKind;
+  swift_layout_kind_t Kind;
 
   unsigned Size;
   unsigned Alignment;
@@ -71,6 +78,7 @@ typedef struct swift_childinfo {
   /// The memory for Name is owned by the reflection context.
   const char *Name;
   unsigned Offset;
+  swift_layout_kind_t Kind;
   swift_typeref_t TR;
 } swift_childinfo_t;
 

stdlib/public/Reflection/TypeLowering.cpp

@@ -107,6 +107,12 @@ class PrintTypeInfo {
       case RecordKind::ThickFunction:
         printHeader("thick_function");
         break;
+      case RecordKind::Existential:
+        printHeader("existential");
+        break;
+      case RecordKind::ClassExistential:
+        printHeader("class_existential");
+        break;
       }
       printBasic(TI);
       printFields(RecordTI);
@@ -224,6 +230,89 @@ class RecordTypeInfoBuilder {
   }
 };
 
+class ExistentialTypeInfoBuilder {
+  TypeConverter &TC;
+  bool ObjC;
+  bool Class;
+  unsigned WitnessTableCount;
+  bool Invalid;
+
+public:
+  ExistentialTypeInfoBuilder(TypeConverter &TC)
+    : TC(TC), ObjC(false), Class(false), WitnessTableCount(0),
+      Invalid(false) {}
+
+  void addProtocol(const TypeRef *TR) {
+    auto *P = dyn_cast<ProtocolTypeRef>(TR);
+    if (P == nullptr) {
+      Invalid = true;
+      return;
+    }
+
+    // FIXME: AnyObject should go away
+    if (P->getMangledName() == "Ps9AnyObject_") {
+      Class = true;
+      return;
+    }
+
+    const FieldDescriptor *FD = TC.getBuilder().getFieldTypeInfo(TR);
+    if (FD == nullptr) {
+      Invalid = true;
+      return;
+    }
+
+    switch (FD->Kind) {
+    case FieldDescriptorKind::ObjCProtocol:
+      ObjC = true;
+      break;
+    case FieldDescriptorKind::ClassProtocol:
+      Class = true;
+      WitnessTableCount++;
+      break;
+    case FieldDescriptorKind::Protocol:
+      WitnessTableCount++;
+      break;
+    case FieldDescriptorKind::Struct:
+    case FieldDescriptorKind::Enum:
+    case FieldDescriptorKind::Class:
+      Invalid = true;
+      break;
+    }
+  }
+
+  const TypeInfo *build() {
+    if (Invalid)
+      return nullptr;
+
+    if (ObjC) {
+      if (WitnessTableCount > 0)
+        return nullptr;
+
+      return TC.getReferenceTypeInfo(ReferenceKind::Strong,
+                                     ReferenceCounting::Unknown);
+    }
+
+    RecordTypeInfoBuilder builder(TC,
+                                  Class
+                                    ? RecordKind::ClassExistential
+                                    : RecordKind::Existential);
+
+    if (Class) {
+      builder.addField("object", TC.getUnknownObjectTypeRef());
+    } else {
+      builder.addField("value", TC.getRawPointerTypeRef());
+      builder.addField("value", TC.getRawPointerTypeRef());
+      builder.addField("value", TC.getRawPointerTypeRef());
+      builder.addField("metadata", TC.getRawPointerTypeRef());
+    }
+
+    for (unsigned i = 0; i < WitnessTableCount; i++)
+      builder.addField("wtable", TC.getRawPointerTypeRef());
+
+    return builder.build();
+  }
+};
+
 }
 
 const ReferenceTypeInfo *
@@ -355,10 +444,16 @@ class LowerType
       //
       // Also this is wrong if we wrap a reference in multiple levels of
       // optionality
-      if (NoPayloadCases == 1 &&
-          PayloadCases == 1 &&
-          isa<ReferenceTypeInfo>(PayloadTI))
-        return PayloadTI;
+      if (NoPayloadCases == 1 && PayloadCases == 1) {
+        if (isa<ReferenceTypeInfo>(PayloadTI))
+          return PayloadTI;
+
+        if (auto *RecordTI = dyn_cast<RecordTypeInfo>(PayloadTI)) {
+          auto SubKind = RecordTI->getRecordKind();
+          if (SubKind == RecordKind::ClassExistential)
+            return PayloadTI;
+        }
+      }
 
       return nullptr;
     }
@@ -399,14 +494,17 @@ class LowerType
   }
 
   const TypeInfo *visitProtocolTypeRef(const ProtocolTypeRef *P) {
-    // FIXME
-    return nullptr;
+    ExistentialTypeInfoBuilder builder(TC);
+    builder.addProtocol(P);
+    return builder.build();
   }
 
   const TypeInfo *
   visitProtocolCompositionTypeRef(const ProtocolCompositionTypeRef *PC) {
-    // FIXME
-    return nullptr;
+    ExistentialTypeInfoBuilder builder(TC);
+    for (auto *P : PC->getProtocols())
+      builder.addProtocol(P);
+    return builder.build();
   }
 
   const TypeInfo *visitMetatypeTypeRef(const MetatypeTypeRef *M) {
@@ -442,16 +540,44 @@ class LowerType
                                    ReferenceCounting::Unknown);
   }
 
+  const TypeInfo *
+  rebuildStorageTypeInfo(const TypeInfo *TI, ReferenceKind Kind) {
+    if (auto *ReferenceTI = dyn_cast<ReferenceTypeInfo>(TI))
+      return TC.getReferenceTypeInfo(Kind, ReferenceTI->getReferenceCounting());
+
+    if (auto *RecordTI = dyn_cast<RecordTypeInfo>(TI)) {
+      auto SubKind = RecordTI->getRecordKind();
+      if (SubKind == RecordKind::ClassExistential) {
+        std::vector<FieldInfo> Fields;
+        for (auto &Field : RecordTI->getFields()) {
+          if (Field.Name == "object") {
+            auto *FieldTI = rebuildStorageTypeInfo(&Field.TI, Kind);
+            Fields.push_back({Field.Name, Field.Offset, Field.TR, *FieldTI});
+            continue;
+          }
+          Fields.push_back(Field);
+        }
+
+        return TC.makeTypeInfo<RecordTypeInfo>(
+            RecordTI->getSize(),
+            RecordTI->getAlignment(),
+            RecordTI->getStride(),
+            RecordTI->getNumExtraInhabitants(),
+            SubKind, Fields);
+      }
+    }
+
+    return nullptr;
+  }
+
   template<typename StorageTypeRef>
   const TypeInfo *
   visitAnyStorageTypeRef(const StorageTypeRef *S, ReferenceKind Kind) {
     auto *TI = TC.getTypeInfo(S->getType());
     if (TI == nullptr)
       return nullptr;
 
-    // FIXME: This might also be a class existential
-    return TC.getReferenceTypeInfo(Kind,
-        cast<ReferenceTypeInfo>(TI)->getReferenceCounting());
+    return rebuildStorageTypeInfo(TI, Kind);
   }
 
   const TypeInfo *

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -77,6 +77,8 @@ TypeRefBuilder::getFieldTypeInfo(const TypeRef *TR) {
     MangledName = N->getMangledName();
   else if (auto BG = dyn_cast<BoundGenericTypeRef>(TR))
     MangledName = BG->getMangledName();
+  else if (auto P = dyn_cast<ProtocolTypeRef>(TR))
+    MangledName = P->getMangledName();
   else
     return {};
 

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -101,6 +101,41 @@ swift_reflection_genericArgumentCountOfTypeRef(swift_typeref_t OpaqueTypeRef) {
   return 0;
 }
 
+swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {
+  switch (TI.getKind()) {
+  case TypeInfoKind::Builtin:
+    return SWIFT_BUILTIN;
+  case TypeInfoKind::Record: {
+    auto &RecordTI = cast<RecordTypeInfo>(TI);
+    switch (RecordTI.getRecordKind()) {
+    case RecordKind::Tuple:
+      return SWIFT_TUPLE;
+    case RecordKind::Struct:
+      return SWIFT_STRUCT;
+    case RecordKind::ThickFunction:
+      return SWIFT_THICK_FUNCTION;
+    case RecordKind::Existential:
+      return SWIFT_EXISTENTIAL;
+    case RecordKind::ClassExistential:
+      return SWIFT_CLASS_EXISTENTIAL;
+    }
+  }
+  case TypeInfoKind::Reference: {
+    auto &ReferenceTI = cast<ReferenceTypeInfo>(TI);
+    switch (ReferenceTI.getReferenceKind()) {
+    case ReferenceKind::Strong:
+      return SWIFT_STRONG_REFERENCE;
+    case ReferenceKind::Unowned:
+      return SWIFT_UNOWNED_REFERENCE;
+    case ReferenceKind::Weak:
+      return SWIFT_WEAK_REFERENCE;
+    case ReferenceKind::Unmanaged:
+      return SWIFT_UNMANAGED_REFERENCE;
+    }
+  }
+  }
+}
+
 swift_typeinfo_t
 swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
                                 swift_typeref_t OpaqueTypeRef) {
@@ -118,50 +153,12 @@ swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
     };
   }
 
-  swift_layout_kind_t Kind;
   unsigned NumFields = 0;
-
-  switch (TI->getKind()) {
-  case TypeInfoKind::Builtin:
-    Kind = SWIFT_BUILTIN;
-    break;
-  case TypeInfoKind::Record: {
-    auto *RecordTI = cast<RecordTypeInfo>(TI);
-    switch (RecordTI->getRecordKind()) {
-    case RecordKind::Tuple:
-      Kind = SWIFT_TUPLE;
-      break;
-    case RecordKind::Struct:
-      Kind = SWIFT_STRUCT;
-      break;
-    case RecordKind::ThickFunction:
-      Kind = SWIFT_THICK_FUNCTION;
-      break;
-    }
+  if (auto *RecordTI = dyn_cast<RecordTypeInfo>(TI))
     NumFields = RecordTI->getNumFields();
-    break;
-  }
-  case TypeInfoKind::Reference: {
-    auto *ReferenceTI = cast<ReferenceTypeInfo>(TI);
-    switch (ReferenceTI->getReferenceKind()) {
-    case ReferenceKind::Strong:
-      Kind = SWIFT_STRONG_REFERENCE;
-      break;
-    case ReferenceKind::Unowned:
-      Kind = SWIFT_UNOWNED_REFERENCE;
-      break;
-    case ReferenceKind::Weak:
-      Kind = SWIFT_WEAK_REFERENCE;
-      break;
-    case ReferenceKind::Unmanaged:
-      Kind = SWIFT_UNMANAGED_REFERENCE;
-      break;
-    }
-  }
-  }
 
   return {
-    Kind,
+    getTypeInfoKind(*TI),
     TI->getSize(),
     TI->getAlignment(),
     TI->getStride(),
@@ -182,6 +179,7 @@ swift_reflection_infoForChild(SwiftReflectionContextRef ContextRef,
   return {
     FieldInfo.Name.c_str(),
     FieldInfo.Offset,
+    getTypeInfoKind(FieldInfo.TI),
     reinterpret_cast<swift_typeref_t>(FieldInfo.TR),
   };
 }

test/Reflection/Inputs/TypeLowering.swift

@@ -47,3 +47,24 @@ public struct FunctionStruct {
   public let thinFunction: @convention(thin) () -> ()
   public let cFunction: @convention(c) () -> ()
 }
+
+public protocol P1 {}
+public protocol P2 : P1 {}
+public protocol P3 {}
+
+public protocol CP1 : class {}
+public protocol CP2 : CP1 {}
+
+public struct ExistentialStruct {
+  public let any: Any
+  public let anyObject: AnyObject
+  public let anyProto: P1
+  public let anyProtoComposition: protocol<P1, P2, P3>
+  public let anyClassBoundProto1: CP1
+  public let anyClassBoundProto2: CP2
+  public let anyClassBoundProtoComposition1: protocol<CP1, CP2>
+  public let anyClassBoundProtoComposition2: protocol<P1, CP2>
+
+  public weak var weakAnyObject: AnyObject?
+  public weak var weakAnyClassBoundProto: CP1?
+}