Support concrete type propagation into witness_method instructions only for directly inherited conformances for now

Indirectly inherited conformances cannot be properly handled yet due to some representation issues with init_existential_* instructions.

This fixes a compiler crash reported in rdar://34022255.

Author: swiftix

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -795,12 +795,23 @@ getConformanceAndConcreteType(FullApplySite AI,
     if (Requirement == Protocol) {
       return std::make_tuple(Conformance, ConcreteType, ConcreteTypeDef);
     }
-    if (Requirement->inheritsFrom(Protocol)) {
-      // If Requirement != Protocol, then the abstract conformance cannot be used
-      // as is and we need to create a proper conformance.
-      return std::make_tuple(Conformance.getInherited(Protocol), ConcreteType,
-                             ConcreteTypeDef);
-    }
+    // 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);
   }
 
   llvm_unreachable("couldn't find matching conformance in substitution?");

test/SILOptimizer/devirt_protocol_method_invocations.swift

@@ -7,7 +7,10 @@ protocol PPP {
 protocol QQQ : PPP {
 }
 
-struct S : QQQ {}
+protocol RRR : QQQ {
+}
+
+struct S : RRR {}
 
 extension QQQ {
     @_semantics("optimize.sil.never")
@@ -25,6 +28,18 @@ public func testInheritedConformance() {
     (S() as QQQ).f()
 }
 
+// Test that a witness_method instructions is not devirtualized yet, because
+// it uses indirect inheritance.
+// 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: apply
+// CHECK: // end sil function '_T034devirt_protocol_method_invocations34testIndirectlyInheritedConformanceyyF'
+public func testIndirectlyInheritedConformance() {
+  (S() as RRR).f()
+}
+
+
 public protocol Foo { 
   func foo(_ x:Int) -> Int
 }