Runtime: Support for conditional conformances with pack conformance requirements

Author: slavapestov

include/swift/ABI/Metadata.h

@@ -2596,6 +2596,7 @@ struct TargetProtocolConformanceDescriptor final
              TargetProtocolConformanceDescriptor<Runtime>,
              TargetRelativeContextPointer<Runtime>,
              TargetGenericRequirementDescriptor<Runtime>,
+             GenericPackShapeDescriptor,
              TargetResilientWitnessesHeader<Runtime>,
              TargetResilientWitness<Runtime>,
              TargetGenericWitnessTable<Runtime>> {
@@ -2604,6 +2605,7 @@ struct TargetProtocolConformanceDescriptor final
                              TargetProtocolConformanceDescriptor<Runtime>,
                              TargetRelativeContextPointer<Runtime>,
                              TargetGenericRequirementDescriptor<Runtime>,
+                             GenericPackShapeDescriptor,
                              TargetResilientWitnessesHeader<Runtime>,
                              TargetResilientWitness<Runtime>,
                              TargetGenericWitnessTable<Runtime>>;
@@ -2695,12 +2697,19 @@ struct TargetProtocolConformanceDescriptor final
 
   /// Retrieve the conditional requirements that must also be
   /// satisfied
-  llvm::ArrayRef<GenericRequirementDescriptor>
+  llvm::ArrayRef<TargetGenericRequirementDescriptor<Runtime>>
   getConditionalRequirements() const {
-    return {this->template getTrailingObjects<GenericRequirementDescriptor>(),
+    return {this->template getTrailingObjects<TargetGenericRequirementDescriptor<Runtime>>(),
             Flags.getNumConditionalRequirements()};
   }
 
+  /// Retrieve the pack shape descriptors for the conditional pack requirements.
+  llvm::ArrayRef<GenericPackShapeDescriptor>
+  getConditionalPackShapeDescriptors() const {
+    return {this->template getTrailingObjects<GenericPackShapeDescriptor>(),
+            Flags.getNumConditionalPackShapeDescriptors()};
+  }
+
   /// Get the directly-referenced witness table pattern, which may also
   /// serve as the witness table.
   const swift::TargetWitnessTable<Runtime> *getWitnessTablePattern() const {
@@ -2759,6 +2768,10 @@ struct TargetProtocolConformanceDescriptor final
     return Flags.getNumConditionalRequirements();
   }
 
+  size_t numTrailingObjects(OverloadToken<GenericPackShapeDescriptor>) const {
+    return Flags.getNumConditionalPackShapeDescriptors();
+  }
+
   size_t numTrailingObjects(OverloadToken<ResilientWitnessesHeader>) const {
     return Flags.hasResilientWitnesses() ? 1 : 0;
   }

include/swift/ABI/MetadataValues.h

@@ -662,17 +662,20 @@ class ConformanceFlags {
   enum : int_type {
     UnusedLowBits = 0x07,      // historical conformance kind
 
-    TypeMetadataKindMask = 0x7 << 3, // 8 type reference kinds
+    TypeMetadataKindMask = 0x7u << 3, // 8 type reference kinds
     TypeMetadataKindShift = 3,
 
-    IsRetroactiveMask = 0x01 << 6,
-    IsSynthesizedNonUniqueMask = 0x01 << 7,
+    IsRetroactiveMask = 0x01u << 6,
+    IsSynthesizedNonUniqueMask = 0x01u << 7,
 
-    NumConditionalRequirementsMask = 0xFF << 8,
+    NumConditionalRequirementsMask = 0xFFu << 8,
     NumConditionalRequirementsShift = 8,
 
-    HasResilientWitnessesMask = 0x01 << 16,
-    HasGenericWitnessTableMask = 0x01 << 17,
+    HasResilientWitnessesMask = 0x01u << 16,
+    HasGenericWitnessTableMask = 0x01u << 17,
+
+    NumConditionalPackDescriptorsMask = 0xFFu << 24,
+    NumConditionalPackDescriptorsShift = 24
   };
 
   int_type Value;
@@ -702,6 +705,11 @@ class ConformanceFlags {
                             | (n << NumConditionalRequirementsShift));
   }
 
+  ConformanceFlags withNumConditionalPackDescriptors(unsigned n) const {
+    return ConformanceFlags((Value & ~NumConditionalPackDescriptorsMask)
+                            | (n << NumConditionalPackDescriptorsShift));
+  }
+
   ConformanceFlags withHasResilientWitnesses(bool hasResilientWitnesses) const {
     return ConformanceFlags((Value & ~HasResilientWitnessesMask)
                             | (hasResilientWitnesses? HasResilientWitnessesMask
@@ -747,6 +755,12 @@ class ConformanceFlags {
               >> NumConditionalRequirementsShift;
   }
 
+  /// Retrieve the # of conditional pack shape descriptors.
+  unsigned getNumConditionalPackShapeDescriptors() const {
+    return (Value & NumConditionalPackDescriptorsMask)
+              >> NumConditionalPackDescriptorsShift;
+  }
+
   /// Whether this conformance has any resilient witnesses.
   bool hasResilientWitnesses() const {
     return Value & HasResilientWitnessesMask;

stdlib/public/runtime/Metadata.cpp

@@ -5678,6 +5678,7 @@ instantiateWitnessTable(const Metadata *Type,
                         void **fullTable) {
   auto protocol = conformance->getProtocol();
   auto genericTable = conformance->getGenericWitnessTable();
+  auto *genericArgs = Type->getGenericArgs();
 
   // The number of witnesses provided by the table pattern.
   size_t numPatternWitnesses = genericTable->WitnessTableSizeInWords;
@@ -5719,20 +5720,38 @@ instantiateWitnessTable(const Metadata *Type,
   // requirements into the private area.
   {
     unsigned currentInstantiationArg = 0;
-    auto copyNextInstantiationArg = [&] {
-      assert(currentInstantiationArg < privateSizeInWords);
-      table[-1 - (int)currentInstantiationArg] =
-        const_cast<void *>(instantiationArgs[currentInstantiationArg]);
-      ++currentInstantiationArg;
-    };
+
+    llvm::ArrayRef<GenericPackShapeDescriptor> packShapeDescriptors =
+        conformance->getConditionalPackShapeDescriptors();
+    unsigned packIdx = 0;
 
     for (const auto &conditionalRequirement
           : conformance->getConditionalRequirements()) {
-      if (conditionalRequirement.Flags.hasKeyArgument())
-        copyNextInstantiationArg();
+      if (!conditionalRequirement.Flags.hasKeyArgument())
+        continue;
 
-      assert(!conditionalRequirement.Flags.isPackRequirement() &&
-             "Packs not supported here yet");
+      assert(currentInstantiationArg < privateSizeInWords);
+
+      auto *instantiationArg = instantiationArgs[currentInstantiationArg];
+
+      // Heap-allocate witness tables for conditional pack conformance requirements.
+      if (conditionalRequirement.Flags.isPackRequirement()) {
+        auto packShapeDescriptor = packShapeDescriptors[packIdx];
+        assert(packShapeDescriptor.Kind == GenericPackKind::WitnessTable);
+        assert(packShapeDescriptor.Index == currentInstantiationArg);
+        size_t count = reinterpret_cast<const size_t>(
+            genericArgs[packShapeDescriptor.ShapeClass]);
+
+        auto *wtable = reinterpret_cast<const WitnessTable * const*>(instantiationArg);
+        wtable = swift_allocateWitnessTablePack(wtable, count);
+
+        instantiationArg = wtable;
+        ++packIdx;
+      }
+
+      table[-1 - (int)currentInstantiationArg] = const_cast<void *>(instantiationArg);
+
+      ++currentInstantiationArg;
     }
   }
 
@@ -6047,6 +6066,9 @@ instantiateRelativeWitnessTable(const Metadata *Type,
           : conformance->getConditionalRequirements()) {
       if (conditionalRequirement.Flags.hasKeyArgument())
         copyNextInstantiationArg();
+
+      assert(!conditionalRequirement.Flags.isPackRequirement() &&
+             "Not supported yet");
     }
   }
 

stdlib/public/runtime/MetadataLookup.cpp

@@ -1283,6 +1283,9 @@ _gatherGenericParameters(const ContextDescriptor *context,
       }
 
       // Add metadata for each canonical generic parameter.
+      auto packShapeDescriptors = generics->getGenericPackShapeDescriptors();
+      unsigned packIdx = 0;
+
       for (unsigned i = 0; i != n; ++i) {
         const auto &param = genericParams[i];
         auto arg = allGenericArgs[i];
@@ -1313,7 +1316,20 @@ _gatherGenericParameters(const ContextDescriptor *context,
           }
 
           if (param.hasKeyArgument()) {
-            allGenericArgsVec.push_back(arg.getMetadataPack().getPointer());
+            auto packShapeDescriptor = packShapeDescriptors[packIdx];
+            assert(packShapeDescriptor.Kind == GenericPackKind::Metadata);
+            assert(packShapeDescriptor.Index == allGenericArgsVec.size());
+            assert(packShapeDescriptor.ShapeClass < packShapeHeader.NumShapeClasses);
+
+            auto argPack = arg.getMetadataPack();
+            assert(argPack.getLifetime() == PackLifetime::OnHeap);
+
+            // Fill in the length for each shape class.
+            allGenericArgsVec[packShapeDescriptor.ShapeClass] =
+                reinterpret_cast<const void *>(argPack.getNumElements());
+
+            allGenericArgsVec.push_back(argPack.getPointer());
+            ++packIdx;
           }
 
           break;
@@ -1327,22 +1343,6 @@ _gatherGenericParameters(const ContextDescriptor *context,
           });
         }
       }
-
-      // Fill in the length for each shape class.
-      auto packShapeDescriptors = generics->getGenericPackShapeDescriptors();
-      for (auto packShapeDescriptor : packShapeDescriptors) {
-        if (packShapeDescriptor.Kind != GenericPackKind::Metadata)
-          continue;
-
-        assert(packShapeDescriptor.Index < allGenericArgsVec.size());
-        assert(packShapeDescriptor.ShapeClass < packShapeHeader.NumShapeClasses);
-
-        MetadataPackPointer pack(allGenericArgsVec[packShapeDescriptor.Index]);
-        assert(pack.getLifetime() == PackLifetime::OnHeap);
-
-        allGenericArgsVec[packShapeDescriptor.ShapeClass] =
-            reinterpret_cast<const void *>(pack.getNumElements());
-      }
     }
 
     // Check whether the generic requirements are satisfied, collecting

test/Interpreter/variadic_generic_conditional_conformances.swift

@@ -0,0 +1,48 @@
+// RUN: %target-run-simple-swift(-Xfrontend -disable-availability-checking)
+
+// REQUIRES: executable_test
+
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: back_deployment_runtime
+
+import StdlibUnittest
+
+var conformances = TestSuite("VariadicGenericConformances")
+
+protocol P {
+  static func foobar() -> [String]
+}
+
+struct G<each T> {}
+
+extension G: P where repeat each T: P {
+  static func foobar() -> [String] {
+    var result: [String] = []
+    repeat result += (each T).foobar()
+    return result
+  }
+}
+
+extension Int: P {
+  static func foobar() -> [String] {
+    return ["Int"]
+  }
+}
+
+extension String: P {
+  static func foobar() -> [String] {
+    return ["String"]
+  }
+}
+
+func callFoobar<T: P>(_: T) -> [String] {
+  return T.foobar()
+}
+
+conformances.test("conditional") {
+  expectEqual([], callFoobar(G< >()))
+  expectEqual(["Int"], callFoobar(G<Int>()))
+  expectEqual(["Int", "String"], callFoobar(G<Int, String>()))
+}
+
+runAllTests()

test/Interpreter/variadic_generic_conformances.swift

@@ -7,7 +7,7 @@
 
 import StdlibUnittest
 
-var tuples = TestSuite("VariadicGenericConformances")
+var conformances = TestSuite("VariadicGenericConformances")
 
 protocol TypeMaker {
   func makeType() -> Any.Type
@@ -29,7 +29,7 @@ struct ElementTupleMaker<each T: Sequence> : TypeMaker {
   }
 }
 
-tuples.test("makeTuple1") {
+conformances.test("makeTuple1") {
   expectEqual("()", _typeName(makeTypeIndirectly(TupleMaker< >())))
 
   // FIXME: This should unwrap the one-element tuple!
@@ -38,7 +38,7 @@ tuples.test("makeTuple1") {
   expectEqual("(Swift.Int, Swift.Bool)", _typeName(makeTypeIndirectly(TupleMaker<Int, Bool>())))
 }
 
-tuples.test("makeTuple2") {
+conformances.test("makeTuple2") {
   expectEqual("()", _typeName(makeTypeIndirectly(ElementTupleMaker< >())))
 
   // FIXME: This should unwrap the one-element tuple!
@@ -88,7 +88,7 @@ func testPackRequirements2<T: HasPackRequirements, each U: Q>(_ t: T, _ u: repea
   return t.doStuff2(repeat each u)
 }
 
-tuples.test("packRequirements") {
+conformances.test("packRequirements") {
   expectEqual(([1], ["hi"], [false]), testPackRequirements1(ConformsPackRequirements(), 1, "hi", false))
   expectEqual(([1], ["hi"], [false]), testPackRequirements2(ConformsPackRequirements(), 1, "hi", false))
 }