[sil-devirtualizer] Fix some bugs in the devirtualizer.

- Don't crash if a class_method instruction could not be devirtualized.
- Improve devirtualization of methods with generic parameters and using dependent types.
- Fix a bug in isBindableToSuperclassOf, uncovered while fixing the original bug reported in SR-1206.
  This bug could lead in certain cases to invocations of a wrong method from the base class, instead
  of using a method from a derived class.

rdar://25891588   and SR-1206

Author: swiftix

lib/AST/Type.cpp

@@ -1804,8 +1804,9 @@ static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
                  == substSubs[subi].getConformances().size());
           for (unsigned conformancei :
                  indices(origSubs[subi].getConformances())) {
-            if (origSubs[subi].getConformances()[conformancei]
-                  != substSubs[subi].getConformances()[conformancei])
+            if (origSubs[subi].getConformances()[conformancei].isConcrete() &&
+                origSubs[subi].getConformances()[conformancei] !=
+                    substSubs[subi].getConformances()[conformancei])
               return false;
           }
         }

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -509,10 +509,11 @@ static bool tryToSpeculateTarget(FullApplySite AI,
     return true;
   }
   auto NewInstPair = tryDevirtualizeClassMethod(AI, SubTypeValue);
-  assert(NewInstPair.first && "Expected to be able to devirtualize apply!");
-  replaceDeadApply(AI, NewInstPair.first);
-
-  return true;
+  if (NewInstPair.first) {
+    replaceDeadApply(AI, NewInstPair.first);
+    return true;
+  }
+  return Changed;
 }
 
 namespace {

lib/SILOptimizer/Utils/Devirtualize.cpp

@@ -389,17 +389,30 @@ getSubstitutionsForCallee(SILModule &M, CanSILFunctionType GenCalleeType,
   CanSILFunctionType AIGenCalleeType =
       AI.getCallee()->getType().castTo<SILFunctionType>();
 
-  CanType AISelfClass = AIGenCalleeType->getSelfParameter().getType();
-
   unsigned NextMethodParamIdx = 0;
   unsigned NumMethodParams = 0;
   if (AIGenCalleeType->isPolymorphic()) {
-    NextMethodParamIdx = 0;
-    // Generic parameters of the method start after generic parameters
-    // of the instance class.
-    if (auto AISelfClassSig =
-            AISelfClass.getClassBound()->getGenericSignature()) {
-      NextMethodParamIdx = AISelfClassSig->getGenericParams().size();
+    NextMethodParamIdx = AISubs.size();
+    if (auto AIMethodSig = AI.getOrigCalleeType()->getGenericSignature()) {
+      // Find out if the apply instruction contains any substitutions for
+      // a method itself, not for the class where it is declared.
+      // If there are any such parameters, remember where they start
+      // in the substitutions list.
+      auto InnermostGenericParams = AIMethodSig->getInnermostGenericParams();
+      auto InnermostGenericParamsNum = InnermostGenericParams.size();
+      if (InnermostGenericParamsNum != AIMethodSig->getGenericParams().size()) {
+        auto Depth = InnermostGenericParams[0]->getDepth();
+        for (NextMethodParamIdx = 0; NextMethodParamIdx < AISubs.size();
+             ++NextMethodParamIdx) {
+          if (auto SubstTy = dyn_cast<SubstitutedType>(
+                  AISubs[NextMethodParamIdx].getReplacement().getPointer())) {
+            if (auto *GenParamTy = dyn_cast<GenericTypeParamType>(
+                    SubstTy->getOriginal().getPointer()))
+              if (GenParamTy->getDepth() == Depth)
+                break;
+          }
+        }
+      }
     }
     NumMethodParams = AISubs.size() - NextMethodParamIdx;
   }
@@ -477,37 +490,42 @@ bool swift::canDevirtualizeClassMethod(FullApplySite AI,
       return false;
   }
 
+  // Type of the actual function to be called.
   CanSILFunctionType GenCalleeType = F->getLoweredFunctionType();
 
-  auto Subs = getSubstitutionsForCallee(Mod, GenCalleeType,
-                                        ClassOrMetatypeType, AI);
+  // Type of the actual function to be called with substitutions applied.
+  CanSILFunctionType SubstCalleeType = GenCalleeType;
 
   // For polymorphic functions, bail if the number of substitutions is
   // not the same as the number of expected generic parameters.
   if (GenCalleeType->isPolymorphic()) {
+    // First, find proper list of substitutions for the concrete
+    // method to be called.
+    auto Subs = getSubstitutionsForCallee(Mod, GenCalleeType,
+                                          ClassOrMetatypeType, AI);
+
     auto GenericSig = GenCalleeType->getGenericSignature();
     // Get the number of expected generic parameters, which
     // is a sum of the number of explicit generic parameters
     // and the number of their recursive member types exposed
     // through protocol requirements.
     auto DepTypes = GenericSig->getAllDependentTypes();
-    unsigned ExpectedGenParamsNum = 0;
+    unsigned ExpectedSubsNum = 0;
 
     for (auto DT: DepTypes) {
       (void)DT;
-      ExpectedGenParamsNum++;
+      ExpectedSubsNum++;
     }
 
-    if (ExpectedGenParamsNum != Subs.size())
+    if (ExpectedSubsNum != Subs.size()) {
       return false;
-  }
+    }
 
-  // Check if the optimizer knows how to cast the return type.
-  CanSILFunctionType SubstCalleeType = GenCalleeType;
-  if (GenCalleeType->isPolymorphic())
     SubstCalleeType =
         GenCalleeType->substGenericArgs(Mod, Mod.getSwiftModule(), Subs);
+  }
 
+  // Check if the optimizer knows how to cast the return type.
   SILType ReturnType = SubstCalleeType->getSILResult();
 
   if (!canCastValueToABICompatibleType(Mod, ReturnType, AI.getType()))

test/SILOptimizer/devirt_unbound_generic.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -emit-sil -O -emit-sil %s | FileCheck %s
+// RUN: %target-swift-frontend -emit-sil -O %s | FileCheck %s
 
 // We used to crash on this when trying to devirtualize t.boo(a, 1),
 // because it is an "apply" with unbound generic arguments and
@@ -73,3 +73,134 @@ func test3<T>(_ d: Derived<T>) {
 public func doTest3<T>(_ t:T) {
   test3(Derived<T>())
 }
+
+
+public protocol ProtocolWithAssocType {
+  associatedtype Element
+}
+
+private class CP<Base: ProtocolWithAssocType> {
+   var value: Base.Element
+   init(_ v: Base.Element) {
+     value = v
+   }
+
+   func getCount() -> Int32 {
+     return 1
+   }
+}
+
+private class Base1: ProtocolWithAssocType {
+   typealias Element = Int32
+}
+
+
+private class Base2<T>: ProtocolWithAssocType {
+   typealias Element = Int32
+}
+
+private class CP2: CP<Base2<Int>> {
+  init() {
+    super.init(1)
+  }
+
+  override func getCount() -> Int32 {
+    return 2
+  }
+}
+
+private class CP3: CP<Base2<Int>> {
+  init() {
+    super.init(1)
+  }
+
+  override func getCount() -> Int32 {
+    return 3
+  }
+}
+
+public class CC<CT> {
+   func next() -> CT? {
+     return nil
+   }
+}
+
+public protocol QQ {
+  associatedtype Base: PP
+}
+
+public protocol PP {
+  associatedtype Element
+}
+
+internal class D<DT: QQ> : CC<DT.Base.Element> {
+  override func next() -> DT.Base.Element? {
+    return nil
+  }
+}
+
+public struct S: PP {
+  public typealias Element = Int32
+}
+
+final public class E: QQ {
+  public typealias Base = S
+}
+
+// Check that c.next() inside test4 gets completely devirtualized.
+// CHECK-LABEL: sil @{{.*}}test4
+// CHECK-NOT: class_method
+// CHECK: return
+public func test4() -> Int32? {
+  let c: CC<Int32> = D<E>();
+  return c.next()
+}
+
+public func test5() -> Int32? {
+  return testDevirt(D<E>())
+}
+
+// Check that testDevirt is specialized and uses speculative devirtualization.
+// CHECK-LABEL: sil shared [noinline] @{{.*}}testDevirt
+// CHECK: checked_cast_br [exact] %{{.*}} : $CC<Int32> to $CC<Int32>
+// CHECK: class_method
+// CHECK: }
+@inline(never)
+public func testDevirt<T>(_ c: CC<T>) -> T? {
+  return c.next()
+}
+
+// The compiler used to crash on this code, because of
+// generic types involved in the devirtualization.
+//
+// rdar://25891588
+//
+// CHECK-LABEL: sil private [noinline] @{{.*}}test6
+// CHECK-NOT: class_method
+// CHECK-NOT: checked_cast_br
+// CHECK-NOT: class_method
+// CHECK: }
+@inline(never)
+private func test6<T: ProtocolWithAssocType>(_ c: CP<T>) -> T.Element {
+  return c.value
+}
+
+public func doTest6() {
+  test6(CP<Base1>(1))
+}
+
+// CHECK-LABEL: sil private [noinline] @{{.*}}test7
+// CHECK-NOT: class_method
+// CHECK: checked_cast_br
+// CHECK-NOT: class_method
+// CHECK: }
+@inline(never)
+private func test7<T: ProtocolWithAssocType>(_ c: CP<T>) -> Int32 {
+  return c.getCount()
+}
+
+public func doTest7() {
+  test7(CP2())
+}
+
+