Merge pull request #3269 from slavapestov/single-payload-enum-reflection

Single payload enum reflection

Author: slavapestov

include/swift/Reflection/Records.h

@@ -27,19 +27,21 @@ namespace reflection {
 class FieldRecordFlags {
   using int_type = uint32_t;
   enum : int_type {
-    IsObjC = 0x00000001,
+    // Is this an indirect enum case?
+    IsIndirectCase = 0x1
   };
   int_type Data;
+
 public:
-  bool isObjC() const {
-    return Data & IsObjC;
+  bool isIndirectCase() const {
+    return (Data & IsIndirectCase) == IsIndirectCase;
   }
 
-  void setIsObjC(bool ObjC) {
-    if (ObjC)
-      Data |= IsObjC;
+  void setIsIndirectCase(bool IndirectCase=true) {
+    if (IndirectCase)
+      Data |= IsIndirectCase;
     else
-      Data &= ~IsObjC;
+      Data &= ~IsIndirectCase;
   }
 
   int_type getRawValue() const {
@@ -69,8 +71,8 @@ class FieldRecord {
     return "";
   }
 
-  bool isObjC() const {
-    return Flags.isObjC();
+  bool isIndirectCase() const {
+    return Flags.isIndirectCase();
   }
 };
 

include/swift/Reflection/ReflectionContext.h

@@ -190,7 +190,8 @@ class ReflectionContext
     // Class existentials have trivial layout.
     // It is itself the pointer to the instance followed by the witness tables.
     case RecordKind::ClassExistential:
-      *OutInstanceTR = getBuilder().getTypeConverter().getUnknownObjectTypeRef();
+      // This is just Builtin.UnknownObject
+      *OutInstanceTR = ExistentialRecordTI->getFields()[0].TR;
       *OutInstanceAddress = ExistentialAddress;
       return true;
 
@@ -342,11 +343,13 @@ class ReflectionContext
       return nullptr;
 
     // Initialize the builder.
-    Builder.addField(OffsetToFirstCapture.second, sizeof(StoredPointer));
+    Builder.addField(OffsetToFirstCapture.second, sizeof(StoredPointer),
+                     /*numExtraInhabitants=*/0);
 
     // Skip the closure's necessary bindings struct, if it's present.
     auto SizeOfNecessaryBindings = Info.NumBindings * sizeof(StoredPointer);
-    Builder.addField(SizeOfNecessaryBindings, sizeof(StoredPointer));
+    Builder.addField(SizeOfNecessaryBindings, sizeof(StoredPointer),
+                     /*numExtraInhabitants=*/0);
 
     // FIXME: should be unordered_set but I'm too lazy to write a hash
     // functor

include/swift/Reflection/TypeLowering.h

@@ -34,10 +34,23 @@ class TypeRef;
 class TypeRefBuilder;
 class BuiltinTypeDescriptor;
 
+// Defined in TypeLowering.cpp, not public -- they're friends below
+class LowerType;
+class RecordTypeInfoBuilder;
+class ExistentialTypeInfoBuilder;
+
 enum class RecordKind : unsigned {
   Tuple,
   Struct,
 
+  // An enum with no payload cases. The record will have no fields, but
+  // will have the correct size.
+  NoPayloadEnum,
+
+  // An enum with a single payload case. The record consists of a single
+  // field, being the enum payload.
+  SinglePayloadEnum,
+
   // A Swift-native function is always a function pointer followed by a
   // retainable, nullable context pointer.
   ThickFunction,
@@ -185,10 +198,16 @@ class TypeConverter {
   llvm::DenseMap<const TypeRef *, const TypeInfo *> Cache;
   llvm::DenseMap<std::pair<unsigned, unsigned>,
                  const ReferenceTypeInfo *> ReferenceCache;
+
   const TypeRef *RawPointerTR = nullptr;
   const TypeRef *NativeObjectTR = nullptr;
   const TypeRef *UnknownObjectTR = nullptr;
+  const TypeRef *ThinFunctionTR = nullptr;
+  const TypeRef *AnyMetatypeTR = nullptr;
+
+  const TypeInfo *ThinFunctionTI = nullptr;
   const TypeInfo *ThickFunctionTI = nullptr;
+  const TypeInfo *AnyMetatypeTI = nullptr;
   const TypeInfo *EmptyTI = nullptr;
 
 public:
@@ -216,15 +235,29 @@ class TypeConverter {
                                            unsigned start,
                                            unsigned align);
 
-  /* Not really public */
+private:
+  friend class swift::reflection::LowerType;
+  friend class swift::reflection::RecordTypeInfoBuilder;
+  friend class swift::reflection::ExistentialTypeInfoBuilder;
+
   const ReferenceTypeInfo *
   getReferenceTypeInfo(ReferenceKind Kind,
                        ReferenceCounting Refcounting);
 
+  /// TypeRefs for special types for which we need to know the layout
+  /// intrinsically in order to layout anything else.
+  ///
+  /// IRGen emits BuiltinTypeDescriptors for these when compiling the
+  /// standard library.
   const TypeRef *getRawPointerTypeRef();
   const TypeRef *getNativeObjectTypeRef();
   const TypeRef *getUnknownObjectTypeRef();
+  const TypeRef *getThinFunctionTypeRef();
+  const TypeRef *getAnyMetatypeTypeRef();
+
+  const TypeInfo *getThinFunctionTypeInfo();
   const TypeInfo *getThickFunctionTypeInfo();
+  const TypeInfo *getAnyMetatypeTypeInfo();
   const TypeInfo *getEmptyTypeInfo();
 
   template <typename TypeInfoTy, typename... Args>
@@ -242,18 +275,20 @@ class RecordTypeInfoBuilder {
   unsigned Size, Alignment, Stride, NumExtraInhabitants;
   RecordKind Kind;
   std::vector<FieldInfo> Fields;
+  bool Empty;
   bool Invalid;
 
 public:
   RecordTypeInfoBuilder(TypeConverter &TC, RecordKind Kind)
     : TC(TC), Size(0), Alignment(1), Stride(0), NumExtraInhabitants(0),
-      Kind(Kind), Invalid(false) {}
+      Kind(Kind), Empty(true), Invalid(false) {}
 
   bool isInvalid() const {
     return Invalid;
   }
 
-  unsigned addField(unsigned fieldSize, unsigned fieldAlignment);
+  unsigned addField(unsigned fieldSize, unsigned fieldAlignment,
+                    unsigned numExtraInhabitants);
   void addField(const std::string &Name, const TypeRef *TR);
   const RecordTypeInfo *build();
 
@@ -264,6 +299,13 @@ class RecordTypeInfoBuilder {
   unsigned getFieldOffset(unsigned Index) const {
     return Fields[Index].Offset;
   }
+
+  void setNumExtraInhabitants(unsigned numExtraInhabitants) {
+    // We can only take away extra inhabitants while performing
+    // record layout, never add new ones.
+    assert(numExtraInhabitants <= NumExtraInhabitants);
+    NumExtraInhabitants = numExtraInhabitants;
+  }
 };
 
 }

include/swift/Reflection/TypeRefBuilder.h

@@ -92,6 +92,28 @@ struct ClosureContextInfo {
   void dump(std::ostream &OS) const;
 };
 
+struct FieldTypeInfo {
+  std::string Name;
+  const TypeRef *TR;
+  bool Indirect;
+
+  FieldTypeInfo() : Name(""), TR(nullptr), Indirect(false) {}
+  FieldTypeInfo(const std::string &Name, const TypeRef *TR, bool Indirect)
+      : Name(Name), TR(TR), Indirect(Indirect) {}
+
+  static FieldTypeInfo forEmptyCase(std::string Name) {
+    return FieldTypeInfo(Name, nullptr, false);
+  }
+
+  static FieldTypeInfo forIndirectCase(std::string Name, const TypeRef *TR) {
+    return FieldTypeInfo(Name, TR, true);
+  }
+
+  static FieldTypeInfo forField(std::string Name, const TypeRef *TR) {
+    return FieldTypeInfo(Name, TR, false);
+  }
+};
+
 /// An implementation of MetadataReader's BuilderType concept for
 /// building TypeRefs, and parsing field metadata from any images
 /// it has been made aware of.
@@ -286,7 +308,7 @@ class TypeRefBuilder {
   const FieldDescriptor *getFieldTypeInfo(const TypeRef *TR);
 
   /// Get the parsed and substituted field types for a nominal type.
-  std::vector<std::pair<std::string, const TypeRef *>>
+  std::vector<FieldTypeInfo>
   getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD);
 
   /// Get the primitive type lowering for a builtin type.

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -63,7 +63,17 @@ typedef enum swift_layout_kind {
   // Value types consisting of zero or more fields.
   SWIFT_TUPLE,
   SWIFT_STRUCT,
+
+  // An enum with no payload cases. The record will have no fields, but
+  // will have the correct size.
+  SWIFT_NO_PAYLOAD_ENUM,
+
+  // An enum with a single payload case. The record consists of a single
+  // field, being the enum payload.
+  SWIFT_SINGLE_PAYLOAD_ENUM,
+
   SWIFT_THICK_FUNCTION,
+
   SWIFT_OPAQUE_EXISTENTIAL,
   SWIFT_CLASS_EXISTENTIAL,
   SWIFT_ERROR_EXISTENTIAL,