SILCombiner: Use ASTContext::getExistentialSignature()

This addresses the unsupported case outlined in the FIXME.

We have an init_existential_{addr,ref} instruction which
constructs an existential of type R from a value whose
concrete type conforms to R.

Later on, we have a witness_method invoking a method of P,
where R refines Q refines P.

In order to give the witness_method instruction the correct
conformance after substituting the concrete type, we would
call ProtocolConformanceRef::getInherited().

However, this only supported a single level of protocol
refinement, so we would just bail out in the unsupported
case. Instead, this patch builds a SubstitutionMap from the
generic signature <T : R>, and uses the SubstitutionMap to
perform the conformance lookup of T to P.

Author: slavapestov

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -753,70 +753,69 @@ SILCombiner::createApplyWithConcreteType(FullApplySite AI,
 /// Derive a concrete type of self and conformance from the init_existential
 /// instruction.
 static Optional<std::tuple<ProtocolConformanceRef, CanType, SILValue, SILValue>>
-getConformanceAndConcreteType(FullApplySite AI,
+getConformanceAndConcreteType(ASTContext &Ctx,
+                              FullApplySite AI,
                               SILInstruction *InitExistential,
                               ProtocolDecl *Protocol,
                               ArrayRef<ProtocolConformanceRef> &Conformances) {
   // Try to derive the concrete type of self from the found init_existential.
   CanType ConcreteType;
+  // The existential type result of the found init_existential.
+  CanType ExistentialType;
   SILValue ConcreteTypeDef;
   SILValue NewSelf;
 
+  // FIXME: Factor this out. All we really need here is the ExistentialSig
+  // below, which should be stored directly in the SILInstruction.
   if (auto IE = dyn_cast<InitExistentialAddrInst>(InitExistential)) {
     Conformances = IE->getConformances();
     ConcreteType = IE->getFormalConcreteType();
     NewSelf = IE;
+    ExistentialType = IE->getOperand()->getType().getSwiftRValueType();
   } else if (auto IER = dyn_cast<InitExistentialRefInst>(InitExistential)) {
     Conformances = IER->getConformances();
     ConcreteType = IER->getFormalConcreteType();
     NewSelf = IER->getOperand();
+    ExistentialType = IER->getType().getSwiftRValueType();
   } else if (auto IEM = dyn_cast<InitExistentialMetatypeInst>(InitExistential)){
     Conformances = IEM->getConformances();
     NewSelf = IEM->getOperand();
     ConcreteType = NewSelf->getType().getSwiftRValueType();
-
-    auto ExType = IEM->getType().getSwiftRValueType();
-    while (auto ExMetatype = dyn_cast<ExistentialMetatypeType>(ExType)) {
-      ExType = ExMetatype.getInstanceType();
+    ExistentialType = IEM->getType().getSwiftRValueType();
+    while (auto InstanceType = dyn_cast<ExistentialMetatypeType>(ExistentialType)) {
+      ExistentialType = InstanceType.getInstanceType();
       ConcreteType = cast<MetatypeType>(ConcreteType).getInstanceType();
     }
   } else {
     return None;
   }
 
+  // Construct a substitution map from the existential type's generic
+  // parameter to the concrete type.
+  auto ExistentialSig = Ctx.getExistentialSignature(ExistentialType,
+                                                    AI.getModule().getSwiftModule());
+
+  Substitution ConcreteSub(ConcreteType, Conformances);
+  auto SubMap = ExistentialSig->getSubstitutionMap({&ConcreteSub, 1});
+
+  // If the requirement is in a base protocol that is refined by the
+  // conforming protocol, fish out the exact conformance for the base
+  // protocol using the substitution map.
+  auto ExactConformance = SubMap.lookupConformance(
+    CanType(ExistentialSig->getGenericParams()[0]),
+    Protocol);
+
+  // If the concrete type is another existential, we're "forwarding" an
+  // opened existential type, so we must keep track of the original
+  // defining instruction.
   if (ConcreteType->isOpenedExistential()) {
     assert(!InitExistential->getTypeDependentOperands().empty() &&
            "init_existential is supposed to have a typedef operand");
     ConcreteTypeDef = InitExistential->getTypeDependentOperands()[0].get();
   }
 
-  // Find the conformance for the protocol we're interested in.
-  for (auto Conformance : Conformances) {
-    auto Requirement = Conformance.getRequirement();
-    if (Requirement == Protocol) {
-      return std::make_tuple(Conformance, ConcreteType, ConcreteTypeDef,
-                             NewSelf);
-    }
-    // If Requirement != Protocol, then the abstract conformance cannot be
-    // used as is and we need to create a proper conformance.
-    // FIXME: We can handle only direct inheritance at the moment due to some
-    // limitations of the init_existential_* instructions representation.
-    // Once these instructions start using generic signatures instead of
-    // conformances lists, it should be fairly easy to support the indirect
-    // inheritance here by something like:
-    // Substitution Sub(ConcreteType, Conformances);
-    // IE->getGenericSignature()
-    //   ->getSubstitutionMap({Sub}).lookupConformance(GP00, Protocol);
-    auto InheritedProtocols = Requirement->getInheritedProtocols();
-    if (std::find(InheritedProtocols.begin(), InheritedProtocols.end(),
-                  Protocol) == InheritedProtocols.end())
-      return None;
-    // Requirement is directly inherited from Protocol.
-    return std::make_tuple(Conformance.getInherited(Protocol), ConcreteType,
-                           ConcreteTypeDef, NewSelf);
-  }
-
-  llvm_unreachable("couldn't find matching conformance in substitution?");
+  return std::make_tuple(*ExactConformance, ConcreteType,
+                         ConcreteTypeDef, NewSelf);
 }
 
 /// Propagate information about a concrete type from init_existential_addr
@@ -829,6 +828,8 @@ SILCombiner::propagateConcreteTypeOfInitExistential(FullApplySite AI,
     ProtocolDecl *Protocol,
     llvm::function_ref<void(CanType , ProtocolConformanceRef)> Propagate) {
 
+  ASTContext &Ctx = Builder.getASTContext();
+
   // Get the self argument.
   SILValue Self;
   if (auto *Apply = dyn_cast<ApplyInst>(AI)) {
@@ -854,8 +855,8 @@ SILCombiner::propagateConcreteTypeOfInitExistential(FullApplySite AI,
   // the found init_existential.
   ArrayRef<ProtocolConformanceRef> Conformances;
   auto ConformanceAndConcreteType =
-      getConformanceAndConcreteType(AI, InitExistential,
-                                    Protocol, Conformances);
+    getConformanceAndConcreteType(Ctx, AI, InitExistential,
+                                  Protocol, Conformances);
   if (!ConformanceAndConcreteType)
     return nullptr;
 

test/SILOptimizer/devirt_protocol_method_invocations.swift

@@ -28,11 +28,12 @@ public func testInheritedConformance() {
     (S() as QQQ).f()
 }
 
-// Test that a witness_method instructions is not devirtualized yet, because
-// it uses indirect inheritance.
+// Test that a witness_method instruction using an indirectly-inherited conformance
+// is devirtualized.
+//
 // This test used to crash the compiler because it uses inherited conformances.
 // CHECK-LABEL: sil @_T034devirt_protocol_method_invocations34testIndirectlyInheritedConformanceyyF : $@convention(thin) () -> ()
-// CHECK: witness_method
+// CHECK-NOT: witness_method
 // CHECK: apply
 // CHECK: // end sil function '_T034devirt_protocol_method_invocations34testIndirectlyInheritedConformanceyyF'
 public func testIndirectlyInheritedConformance() {