SIL: Serialization for external key path components

Author: jckarter

lib/Serialization/DeserializeSIL.cpp

@@ -2247,7 +2247,8 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
         }
 
         indices = MF->getContext().AllocateCopy(indicesBuf);
-        if (!indices.empty()) {
+        if (!indices.empty() &&
+            kind != KeyPathComponentKindEncoding::External) {
           auto indicesEqualsName = MF->getIdentifier(ListOfValues[nextValue++]);
           auto indicesHashName = MF->getIdentifier(ListOfValues[nextValue++]);
           indicesEquals = getFuncForReference(indicesEqualsName.str());
@@ -2296,6 +2297,21 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
         components.push_back(KeyPathPatternComponent::forOptional(
             KeyPathPatternComponent::Kind::OptionalWrap, type));
         break;
+      case KeyPathComponentKindEncoding::External: {
+        auto declID = ListOfValues[nextValue++];
+        auto decl = cast<AbstractStorageDecl>(MF->getDecl(declID));
+        auto numComponentSubstitutions = ListOfValues[nextValue++];
+        SmallVector<Substitution, 4> subs;
+        while (numComponentSubstitutions-- > 0) {
+          auto sub = MF->maybeReadSubstitution(SILCursor);
+          subs.push_back(*sub);
+        }
+        handleComputedIndices();
+        components.push_back(
+          KeyPathPatternComponent::forExternal(decl,
+            MF->getContext().AllocateCopy(subs), indices, type));
+        break;
+      }
       }
     }
 

lib/Serialization/SILFormat.h

@@ -84,6 +84,7 @@ enum class KeyPathComponentKindEncoding : uint8_t {
   OptionalChain,
   OptionalForce,
   OptionalWrap,
+  External,
 };
 enum class KeyPathComputedComponentIdKindEncoding : uint8_t {
   Property,

lib/Serialization/SerializeSIL.cpp

@@ -1915,7 +1915,25 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
       ListOfValues.push_back(0);
     }
 
-    SmallVector<ProtocolConformanceRef, 4> hashableConformances;
+    // Some components need to serialize additional Substitutions or
+    // ProtocolConformances after the main record is emitted.
+    struct ConformanceOrSubstitution {
+      enum { ProtocolConformance, SubstitutionList } Kind;
+      union {
+        swift::ProtocolConformanceRef Conformance;
+        swift::SubstitutionList Substitutions;
+      };
+      
+      ConformanceOrSubstitution(ProtocolConformanceRef c)
+        : Kind(ProtocolConformance), Conformance(c)
+      {}
+      
+      ConformanceOrSubstitution(swift::SubstitutionList s)
+        : Kind(SubstitutionList), Substitutions(s)
+      {}
+    };
+    SmallVector<ConformanceOrSubstitution, 4> serializeAfter;
+    SmallVector<SubstitutionList, 4> externalSubstitutions;
 
     for (auto &component : pattern->getComponents()) {
       auto handleComponentCommon = [&](KeyPathComponentKindEncoding kind) {
@@ -1951,9 +1969,10 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
             ListOfValues.push_back(
               S.addTypeRef(index.LoweredType.getSwiftRValueType()));
             ListOfValues.push_back((unsigned)index.LoweredType.getCategory());
-            hashableConformances.push_back(index.Hashable);
+            serializeAfter.push_back(index.Hashable);
           }
-          if (!indices.empty()) {
+          if (!indices.empty() &&
+              component.getKind() != KeyPathPatternComponent::Kind::External) {
             ListOfValues.push_back(
               addSILFunctionRef(component.getSubscriptIndexEquals()));
             ListOfValues.push_back(
@@ -1992,7 +2011,12 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
         handleComponentCommon(KeyPathComponentKindEncoding::OptionalWrap);
         break;
       case KeyPathPatternComponent::Kind::External:
-        llvm_unreachable("todo");
+        handleComponentCommon(KeyPathComponentKindEncoding::External);
+        ListOfValues.push_back(S.addDeclRef(component.getExternalDecl()));
+        ListOfValues.push_back(component.getExternalSubstitutions().size());
+        serializeAfter.push_back(component.getExternalSubstitutions());
+        handleComputedIndices(component);
+        break;
       }
     }
 
@@ -2008,8 +2032,15 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
          S.addTypeRef(KPI->getType().getSwiftRValueType()),
          (unsigned)KPI->getType().getCategory(),
          ListOfValues);
-    for (auto conformance : hashableConformances) {
-      S.writeConformance(conformance, SILAbbrCodes);
+    for (auto &confOrSub : serializeAfter) {
+      switch (confOrSub.Kind) {
+      case ConformanceOrSubstitution::ProtocolConformance:
+        S.writeConformance(confOrSub.Conformance, SILAbbrCodes);
+        break;
+      case ConformanceOrSubstitution::SubstitutionList:
+        S.writeSubstitutions(confOrSub.Substitutions, SILAbbrCodes);
+        break;
+      }
     }
     S.writeGenericRequirements(reqts, SILAbbrCodes);
     S.writeSubstitutions(KPI->getSubstitutions(), SILAbbrCodes);

test/SIL/Serialization/keypath.sil

@@ -41,6 +41,12 @@ struct Gen<A: P, B: Q, C: R> {
   var z: C
 }
 
+public struct External<T> {
+  var ro: T { get }
+
+  subscript<U: Hashable>(ro _: U) -> T { get }
+}
+
 // CHECK-LABEL: sil shared [serialized] @stored_properties
 sil shared [serialized] @stored_properties : $@convention(thin) () -> () {
 entry:
@@ -140,6 +146,24 @@ entry(%s : $S, %c : $C):
   return undef : $()
 }
 
+// CHECK-LABEL: sil shared [serialized] @external
+sil shared [serialized] @external : $@convention(thin) <A, B: Hashable> (@in B) -> () {
+entry(%z : $*B):
+  // CHECK: %1 = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+  %a = keypath $KeyPath<External<Int>, Int>, (root $External<Int>; external #External.ro<Int> : $Int)
+
+  // CHECK: %2 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1, τ_0_2> (root $External<τ_0_2>; external #External.ro<τ_0_2> : $τ_0_2) <A, A, A>
+  %b = keypath $KeyPath<External<A>, A>, <C, D, E> (root $External<E>; external #External.ro <E> : $E) <A, A, A>
+
+  // CHECK: %3 = keypath $KeyPath<External<Int>, Int>, <τ_0_0> (root $External<τ_0_0>; external #External.ro<τ_0_0> : $τ_0_0) <Int>
+  %c = keypath $KeyPath<External<Int>, Int>, <F> (root $External<F>; external #External.ro <F> : $F) <Int>
+
+  // CHECK: %4 = keypath $KeyPath<External<A>, A>, <τ_0_0, τ_0_1 where τ_0_0 : Hashable> (root $External<τ_0_1>; external #External.subscript<τ_0_1, τ_0_0>[%$0 : $τ_0_0 : $*τ_0_0] : $τ_0_1) <B, A> (%0)
+  %d = keypath $KeyPath<External<A>, A>, <G: Hashable, H> (root $External<H>; external #External.subscript <H, G> [%$0 : $G : $*G] : $H) <B, A> (%z)
+
+  return undef : $()
+}
+
 sil [serialized] @serialize_all : $@convention(thin) () -> () {
 entry:
   %0 = function_ref @stored_properties : $@convention(thin) () -> ()
@@ -148,6 +172,7 @@ entry:
   %3 = function_ref @computed_properties_generic : $@convention(thin) <D: P, E: Q, F: R> () -> ()
   %4 = function_ref @optional : $@convention(thin) () -> ()
   %5 = function_ref @indexes : $@convention(thin) (S, C) -> ()
+  %6 = function_ref @external : $@convention(thin) <A, B: Hashable> (@in B) -> ()
 
   unreachable
 }