Reflection: Multi-payload enum layout

The approach here is to split this into two cases:

- If all case payloads have a fixed size, spare bits may be
  potentially used to differentiate between cases, and the
  remote reflection library does not have enough information to
  compute the layout itself.

  However, the total size must be fixed, so IRGen just emits a
  builtin type descriptor (which I need to rename to 'fixed type
  descriptor' since these are also used for imported value types,
  and now, certain enums).

- If at least one case has a size that depends on a generic
  parameter or is a resilient type, IRGen does not know the size,
  but this means fancy tricks with spare bits cannot be used either.
  The remote reflection library uses the same approach as the
  runtime, basically taking the maximum of the payload size and
  alignment, and adding a tag byte.

As with single-payload enums, we produce a new kind of
RecordTypeInfo, this time with a field for every enum case.
All cases start at offset zero (but of course this might change,
if for example we put the enum tag before the address point).

Also, just as with single-payload enums, there is no remote
'project case index' operation on ReflectionContext yet.

So the the main benefit from this change is that we don't entirely
give up when doing layout of class instances containing enums;
however, tools still cannot look inside the enum values themselves,
except in the simplest cases involving optionals.

Notably, the remote reflection library finally understands all
of the standard library's collection types -- Array, Character,
Dictionary, Set, and String.

Author: slavapestov

include/swift/Reflection/Records.h

@@ -111,6 +111,14 @@ enum class FieldDescriptorKind : uint16_t {
   Class,
   Enum,
 
+  // Fixed-size multi-payload enums have a special descriptor format that
+  // encodes spare bits.
+  //
+  // FIXME: Actually implement this. For now, a descriptor with this kind
+  // just means we also have a builtin descriptor from which we get the
+  // size and alignment.
+  MultiPayloadEnum,
+
   // A Swift opaque protocol. There are no fields, just a record for the
   // type itself.
   Protocol,
@@ -145,6 +153,22 @@ class FieldDescriptor {
 
   using const_iterator = FieldRecordIterator;
 
+  bool isEnum() const {
+    return (Kind == FieldDescriptorKind::Enum ||
+            Kind == FieldDescriptorKind::MultiPayloadEnum);
+  }
+
+  bool isClass() const {
+    return (Kind == FieldDescriptorKind::Class ||
+            Kind == FieldDescriptorKind::ObjCClass);
+  }
+
+  bool isProtocol() const {
+    return (Kind == FieldDescriptorKind::Protocol ||
+            Kind == FieldDescriptorKind::ClassProtocol ||
+            Kind == FieldDescriptorKind::ObjCProtocol);
+  }
+
   const_iterator begin() const {
     auto Begin = getFieldRecordBuffer();
     auto End = Begin + NumFields;

include/swift/Reflection/TypeLowering.h

@@ -36,11 +36,17 @@ class BuiltinTypeDescriptor;
 
 // Defined in TypeLowering.cpp, not public -- they're friends below
 class LowerType;
+class EnumTypeInfoBuilder;
 class RecordTypeInfoBuilder;
 class ExistentialTypeInfoBuilder;
 
 enum class RecordKind : unsigned {
+  Invalid,
+
+  // A Swift tuple type.
   Tuple,
+
+  // A Swift struct type.
   Struct,
 
   // An enum with no payload cases. The record will have no fields, but
@@ -51,6 +57,10 @@ enum class RecordKind : unsigned {
   // field, being the enum payload.
   SinglePayloadEnum,
 
+  // An enum with multiple payload cases. The record consists of a multiple
+  // fields, one for each enum payload.
+  MultiPayloadEnum,
+
   // A Swift-native function is always a function pointer followed by a
   // retainable, nullable context pointer.
   ThickFunction,
@@ -237,6 +247,7 @@ class TypeConverter {
 
 private:
   friend class swift::reflection::LowerType;
+  friend class swift::reflection::EnumTypeInfoBuilder;
   friend class swift::reflection::RecordTypeInfoBuilder;
   friend class swift::reflection::ExistentialTypeInfoBuilder;
 
@@ -272,15 +283,15 @@ class TypeConverter {
 /// tuples, structs, thick functions, etc.
 class RecordTypeInfoBuilder {
   TypeConverter &TC;
-  unsigned Size, Alignment, Stride, NumExtraInhabitants;
+  unsigned Size, Alignment, 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),
+    : TC(TC), Size(0), Alignment(1), NumExtraInhabitants(0),
       Kind(Kind), Empty(true), Invalid(false) {}
 
   bool isInvalid() const {
@@ -289,7 +300,10 @@ class RecordTypeInfoBuilder {
 
   unsigned addField(unsigned fieldSize, unsigned fieldAlignment,
                     unsigned numExtraInhabitants);
+
+  // Add a field of a record type, such as a struct.
   void addField(const std::string &Name, const TypeRef *TR);
+
   const RecordTypeInfo *build();
 
   unsigned getNumFields() const {
@@ -299,13 +313,6 @@ 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/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -72,6 +72,10 @@ typedef enum swift_layout_kind {
   // field, being the enum payload.
   SWIFT_SINGLE_PAYLOAD_ENUM,
 
+  // An enum with multiple payload cases. The record consists of a multiple
+  // fields, one for each enum payload.
+  SWIFT_MULTI_PAYLOAD_ENUM,
+
   SWIFT_THICK_FUNCTION,
 
   SWIFT_OPAQUE_EXISTENTIAL,

lib/IRGen/GenEnum.h

@@ -173,10 +173,10 @@ class EnumImplStrategy {
   /// storage type, calculates its size and alignment, and produces the
   /// TypeInfo for the enum.
   virtual TypeInfo *completeEnumTypeLayout(TypeConverter &TC,
-                                            SILType Type,
-                                            EnumDecl *theEnum,
-                                            llvm::StructType *enumTy) = 0;
-  
+                                           SILType Type,
+                                           EnumDecl *theEnum,
+                                           llvm::StructType *enumTy) = 0;
+
   const TypeInfo &getTypeInfo() const {
     assert(TI);
     return *TI;

lib/IRGen/GenReflection.cpp

@@ -197,7 +197,7 @@ class ReflectionMetadataBuilder : public ConstantBuilder<> {
           else if (auto PD = dyn_cast<ProtocolDecl>(Nominal))
             IGM.ImportedProtocols.insert(PD);
           else
-            IGM.BuiltinTypes.insert(CanType(t));
+            IGM.OpaqueTypes.insert(Nominal);
         }
     });
   }
@@ -352,7 +352,18 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
         IGM, enumDecl->getDeclaredTypeInContext()
                      ->getCanonicalType());
 
-    addConstantInt16(uint16_t(FieldDescriptorKind::Enum));
+    auto kind = FieldDescriptorKind::Enum;
+
+    // If this is a fixed-size multi-payload enum, we have to emit a descriptor
+    // with the size and alignment of the type, because the reflection library
+    // cannot derive this information at runtime.
+    if (strategy.getElementsWithPayload().size() > 1 &&
+        !strategy.needsPayloadSizeInMetadata()) {
+      kind = FieldDescriptorKind::MultiPayloadEnum;
+      IGM.OpaqueTypes.insert(enumDecl);
+    }
+
+    addConstantInt16(uint16_t(kind));
     addConstantInt16(fieldRecordSize);
     addConstantInt32(strategy.getElementsWithPayload().size() +
                      strategy.getElementsWithNoPayload().size());
@@ -448,25 +459,40 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   }
 };
 
-class BuiltinTypeMetadataBuilder : public ReflectionMetadataBuilder {
-  void addBuiltinType(CanType builtinType) {
-    addTypeRef(builtinType->getASTContext().TheBuiltinModule, builtinType);
+class FixedTypeMetadataBuilder : public ReflectionMetadataBuilder {
+  void addFixedType(Module *module, CanType type,
+                    const FixedTypeInfo &ti) {
+    addTypeRef(module, type);
 
-    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(builtinType));
     addConstantInt32(ti.getFixedSize().getValue());
     addConstantInt32(ti.getFixedAlignment().getValue());
     addConstantInt32(ti.getFixedStride().getValue());
     addConstantInt32(ti.getFixedExtraInhabitantCount(IGM));
   }
 
+  void addBuiltinType(CanType builtinType) {
+    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(builtinType));
+    addFixedType(builtinType->getASTContext().TheBuiltinModule, builtinType, ti);
+  }
+
+  void addOpaqueType(const NominalTypeDecl *nominalDecl) {
+    auto &ti = cast<FixedTypeInfo>(IGM.getTypeInfoForUnlowered(
+        nominalDecl->getDeclaredTypeInContext()->getCanonicalType()));
+
+    addFixedType(nominalDecl->getParentModule(),
+                 nominalDecl->getDeclaredType()->getCanonicalType(), ti);
+  }
+
   void layout() {
-    for (auto builtinType : IGM.BuiltinTypes) {
+    for (auto builtinType : IGM.BuiltinTypes)
       addBuiltinType(builtinType);
-    }
+
+    for (auto nominalDecl : IGM.OpaqueTypes)
+      addOpaqueType(nominalDecl);
   }
 
 public:
-  BuiltinTypeMetadataBuilder(IRGenModule &IGM)
+  FixedTypeMetadataBuilder(IRGenModule &IGM)
     : ReflectionMetadataBuilder(IGM) {}
 
   llvm::GlobalVariable *emit() {
@@ -889,7 +915,7 @@ void IRGenModule::emitBuiltinReflectionMetadata() {
   for (auto PD : ImportedProtocols)
     emitFieldMetadataRecord(PD);
 
-  BuiltinTypeMetadataBuilder builder(*this);
+  FixedTypeMetadataBuilder builder(*this);
   auto var = builder.emit();
   if (var)
     addUsedGlobal(var);

lib/IRGen/IRGenModule.h

@@ -719,12 +719,17 @@ class IRGenModule {
   /// Builtin types referenced by types in this module when emitting
   /// reflection metadata.
   llvm::SetVector<CanType> BuiltinTypes;
+  /// Opaque but fixed-size types for which we also emit builtin type
+  /// descriptors, allowing the reflection library to layout these types
+  /// without knowledge of their contents. This includes imported structs
+  /// and fixed-size multi-payload enums.
+  llvm::SetVector<const NominalTypeDecl *> OpaqueTypes;
   /// Imported classes referenced by types in this module when emitting
   /// reflection metadata.
-  llvm::SetVector<ClassDecl *> ImportedClasses;
+  llvm::SetVector<const ClassDecl *> ImportedClasses;
   /// Imported protocols referenced by types in this module when emitting
   /// reflection metadata.
-  llvm::SetVector<ProtocolDecl *> ImportedProtocols;
+  llvm::SetVector<const ProtocolDecl *> ImportedProtocols;
 
   llvm::Constant *getAddrOfStringForTypeRef(StringRef Str);
   llvm::Constant *getAddrOfFieldName(StringRef Name);