[IRGen] Emit swift_singlePayloadEnumGeneric_destructiveInjectEnumTag

Assign swift_singlePayloadEnumGeneric_destructiveInjectEnumTag as witness function on generic single payload enums when using layout strings

Author: drexin

lib/IRGen/GenValueWitness.cpp

@@ -931,6 +931,38 @@ static llvm::Constant *getEnumTagFunction(IRGenModule &IGM,
   }
 }
 
+static llvm::Constant *
+getDestructiveInjectEnumTagFunction(IRGenModule &IGM,
+                                    const EnumTypeLayoutEntry *typeLayoutEntry,
+                                    GenericSignature genericSig) {
+  if ((!typeLayoutEntry->layoutString(IGM, genericSig) &&
+       !isRuntimeInstatiatedLayoutString(IGM, typeLayoutEntry)) ||
+      typeLayoutEntry->isSingleton()) {
+    return nullptr;
+  } else if (!typeLayoutEntry->isFixedSize(IGM)) {
+    if (typeLayoutEntry->isMultiPayloadEnum()) {
+      return nullptr;
+    } else {
+      return IGM.getSinglePayloadEnumGenericDestructiveInjectEnumTagFn();
+    }
+  } else if (typeLayoutEntry->isMultiPayloadEnum()) {
+    return nullptr;
+  } else {
+    auto &payloadTI = **(typeLayoutEntry->cases[0]->getFixedTypeInfo());
+    auto mask = payloadTI.getFixedExtraInhabitantMask(IGM);
+    auto tzCount = mask.countTrailingZeros();
+    auto shiftedMask = mask.lshr(tzCount);
+    auto toCount = shiftedMask.countTrailingOnes();
+    if (payloadTI.mayHaveExtraInhabitants(IGM) &&
+        (mask.countPopulation() > 64 || toCount != mask.countPopulation() ||
+         (tzCount % toCount != 0))) {
+      return nullptr;
+    } else {
+      return nullptr;
+    }
+  }
+}
+
 static bool
 valueWitnessRequiresCopyability(ValueWitness index) {
   switch (index) {
@@ -1189,8 +1221,31 @@ addValueWitness(IRGenModule &IGM, ConstantStructBuilder &B, ValueWitness index,
     }
     goto standard;
   }
+  case ValueWitness::DestructiveInjectEnumTag: {
+    assert(concreteType.getEnumOrBoundGenericEnum());
+    if (IGM.Context.LangOpts.hasFeature(Feature::LayoutStringValueWitnesses) &&
+        IGM.getOptions().EnableLayoutStringValueWitnesses) {
+      auto ty = boundGenericCharacteristics
+                    ? boundGenericCharacteristics->concreteType
+                    : concreteType;
+      auto &typeInfo = boundGenericCharacteristics
+                           ? *boundGenericCharacteristics->TI
+                           : concreteTI;
+      if (auto *typeLayoutEntry = typeInfo.buildTypeLayoutEntry(
+              IGM, ty, /*useStructLayouts*/ true)) {
+        if (auto *enumLayoutEntry = typeLayoutEntry->getAsEnum()) {
+          auto genericSig = concreteType.getNominalOrBoundGenericNominal()
+                                ->getGenericSignature();
+          if (auto *fn = getDestructiveInjectEnumTagFunction(
+                  IGM, enumLayoutEntry, genericSig)) {
+            return addFunction(fn);
+          }
+        }
+      }
+    }
+    goto standard;
+  }
   case ValueWitness::DestructiveProjectEnumData:
-  case ValueWitness::DestructiveInjectEnumTag:
     assert(concreteType.getEnumOrBoundGenericEnum());
     goto standard;
   }

test/Interpreter/Inputs/layout_string_witnesses_types_resilient.swift

@@ -22,7 +22,7 @@ public struct GenericResilient<C, T> {
 public enum ResilientSinglePayloadEnumGeneric<T> {
     case empty0
     case empty1
-    case nonEmpty0(T)
+    case nonEmpty(T)
 }
 
 public enum ResilientMultiPayloadEnumGeneric<T> {

test/Interpreter/layout_string_witnesses_dynamic.swift

@@ -569,7 +569,7 @@ testResilientMultiPayloadEnumTag()
 
 func testResilientSinglePayloadEnumGenericTag() {
     let x = switch getResilientSinglePayloadEnumGenericEmpty0(AnyObject.self) {
-    case .nonEmpty0: 0
+    case .nonEmpty: 0
     case .empty0: 1
     case .empty1: 2
     }
@@ -594,6 +594,30 @@ func testResilientMultiPayloadEnumGenericTag() {
 
 testResilientMultiPayloadEnumGenericTag()
 
+@inline(never)
+func matchResilientSinglePayloadEnumGenericTag(_ x: ResilientSinglePayloadEnumGeneric<AnyObject>) -> Int {
+    return switch x {
+    case .nonEmpty: 0
+    case .empty0: 1
+    case .empty1: 2
+    }
+}
+
+func testResilientSinglePayloadEnumGenericInjectTag() {
+    let x = ResilientSinglePayloadEnumGeneric<AnyObject>.nonEmpty(SimpleClass(x: 23))
+    let y = ResilientSinglePayloadEnumGeneric<AnyObject>.empty0
+    let z = ResilientSinglePayloadEnumGeneric<AnyObject>.empty1
+
+    // CHECK: Enum case: 0
+    print("Enum case: \(matchResilientSinglePayloadEnumGenericTag(x))")
+    // CHECK: Enum case: 1
+    print("Enum case: \(matchResilientSinglePayloadEnumGenericTag(y))")
+    // CHECK: Enum case: 2
+    print("Enum case: \(matchResilientSinglePayloadEnumGenericTag(z))")
+}
+
+testResilientSinglePayloadEnumGenericInjectTag()
+
 #if os(macOS)
 
 import Foundation