IRGen: Fix extensions of resilient enums

We need to arrange enum type metadata in a way where a client can
fish out generic parameters without knowing if we have a payload
size or not. The payload size is only used inside the module that
defined the enum, and may change if new cases are added.

So put the generic parameters first before the payload size, and
don't crash when an EnumMetadataScanner is used with a resilient
enum.

Author: slavapestov

lib/IRGen/EnumMetadataLayout.h

@@ -52,15 +52,15 @@ template <class Impl> class EnumMetadataLayout : public MetadataLayout<Impl> {
     // emitParentMetadataRef.
 
     // Instantiation-specific.
-    
+
+    // Add fields for generic cases.
+    asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
+
     // Reserve a word to cache the payload size if the type has dynamic layout.
     auto &strategy = getEnumImplStrategy(IGM,
            Target->DeclContext::getDeclaredTypeInContext()->getCanonicalType());
     if (strategy.needsPayloadSizeInMetadata())
       asImpl().addPayloadSize();
-    
-    // Add fields for generic cases.
-    asImpl().addGenericFields(Target, Target->getDeclaredTypeInContext());
   }
 };
 

lib/IRGen/GenEnum.cpp

@@ -4656,7 +4656,7 @@ namespace {
     }
 
     bool needsPayloadSizeInMetadata() const override {
-      llvm_unreachable("resilient enums cannot be defined");
+      return false;
     }
 
     void initializeMetadata(IRGenFunction &IGF,

test/IRGen/enum_resilience.swift

@@ -239,4 +239,17 @@ public func getResilientEnumType() -> Any.Type {
 // CHECK-NEXT: [[RESULT:%.*]] = phi %swift.type* [ [[METADATA]], %entry ], [ [[METADATA2]], %cacheIsNull ]
 // CHECK-NEXT: ret %swift.type* [[RESULT]]
 
+// Methods inside extensions of resilient enums fish out type parameters
+// from metadata -- make sure we can do that
+extension ResilientMultiPayloadGenericEnum {
+
+// CHECK-LABEL: define{{( protected)?}} %swift.type* @_TFE15enum_resilienceO14resilient_enum32ResilientMultiPayloadGenericEnum16getTypeParameterfT_Mx(%swift.type* %"ResilientMultiPayloadGenericEnum<T>", %swift.opaque* noalias nocapture)
+// CHECK: [[METADATA:%.*]] = bitcast %swift.type* %"ResilientMultiPayloadGenericEnum<T>" to %swift.type**
+// CHECK-NEXT: [[T_ADDR:%.*]] = getelementptr inbounds %swift.type*, %swift.type** [[METADATA]], [[INT]] 3
+// CHECK-NEXT: [[T:%.*]] = load %swift.type*, %swift.type** [[T_ADDR]]
+  public func getTypeParameter() -> T.Type {
+    return T.self
+  }
+}
+
 // CHECK-LABEL: define{{( protected)?}} private void @initialize_metadata_EnumWithResilientPayload(i8*)

test/Inputs/resilient_enum.swift

@@ -185,6 +185,14 @@ public enum ResilientMultiPayloadGenericEnum<T> {
   case Y(T)                       // -2
 }
 
+public enum ResilientMultiPayloadGenericEnumFixedSize<T> {
+  case A                          // 0
+  case B                          // 1
+  case C                          // 2
+  case X(Int)                     // -1
+  case Y(Int)                     // -2
+}
+
 public enum ResilientIndirectEnum {
   // 0
   case Base

test/Interpreter/enum_resilience.swift

@@ -404,4 +404,25 @@ ResilientEnumTestSuite.test("ResilientEnumWithEmptyCase") {
   expectEqual(b, [0, 1, 2])
 }
 
+// Methods inside extensions of resilient enums fish out type parameters
+// from metadata -- make sure we can do that
+extension ResilientMultiPayloadGenericEnum {
+  public func getTypeParameter() -> T.Type {
+    return T.self
+  }
+}
+
+extension ResilientMultiPayloadGenericEnumFixedSize {
+  public func getTypeParameter() -> T.Type {
+    return T.self
+  }
+}
+
+class Base {}
+
+ResilientEnumTestSuite.test("ResilientEnumExtension") {
+  expectEqual(Base.self, ResilientMultiPayloadGenericEnum<Base>.A.getTypeParameter())
+  expectEqual(Base.self, ResilientMultiPayloadGenericEnumFixedSize<Base>.A.getTypeParameter())
+}
+
 runAllTests()