Reflection: Single-payload enum layout

Attempt to lay out single-payload enums, using knowledge of extra
inhabitants where possible.

- The extra inhabitants of an aggregate are the extra inhabitants of
  the first field. If the first field is empty, there are no extra
  inhabitants, and subsequent fields do not affect anything.

- Function pointers and metatypes have different extra inhabitants
  than Builtin.RawPointer, so have IRGen emit distinct builtin type
  descriptors for those.

- Opaque existentials do not have extra inhabitants.

- Weak references do not have extra inhabitants.

Also, fix IRGen to emit more accurate enum reflection metadata in
these two cases:

- We now record whether enum cases are indirect or not. An indirect
  case is the same as a payload case with Builtin.NativeObject.

- We now record whether a case is empty or not using the same logic
  as the rest of IRGen. Previously, we would incorrectly emit a
  payload type for a case with a payload that is an empty struct,
  for example.

At this point we don't have a way to get the currently inhabited
enum case from a value. However, this is still an improvement because
we can still reflect other fields of aggregates containing enums,
instead of just giving up.

Finally make some methods on TypeCoverter private, and use 'friend'
to allow them to be accessed from other internal classes, making the
public API simpler.

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,