SILOptimizer: Simplify combineSubstitutionMaps() and fix invariant violation

Fixes rdar://problem/134732867.

Author: slavapestov

lib/SILOptimizer/Utils/Devirtualize.cpp

@@ -407,71 +407,52 @@ combineSubstitutionMaps(SubstitutionMap firstSubMap,
                         GenericSignature genericSig) {
   auto &ctx = genericSig->getASTContext();
 
-  auto replaceGenericParameter = [&](Type type) -> std::optional<Type> {
-    if (auto gp = type->getAs<GenericTypeParamType>()) {
-      if (gp->getDepth() < firstDepth)
-        return Type();
-      return Type(GenericTypeParamType::get(gp->isParameterPack(),
-                                            gp->getDepth() + secondDepth -
-                                                firstDepth,
-                                            gp->getIndex(), ctx));
-    }
-
-    return std::nullopt;
-  };
-
   return SubstitutionMap::get(
     genericSig,
     [&](SubstitutableType *type) {
-      if (auto replacement = replaceGenericParameter(type))
-        if (*replacement)
-          return replacement->subst(secondSubMap);
-      return Type(type).subst(firstSubMap);
+      auto *gp = cast<GenericTypeParamType>(type);
+      if (gp->getDepth() < firstDepth)
+        return QuerySubstitutionMap{firstSubMap}(gp);
+
+      auto *replacement = GenericTypeParamType::get(
+          gp->isParameterPack(),
+          gp->getDepth() + secondDepth - firstDepth,
+          gp->getIndex(), ctx);
+      return QuerySubstitutionMap{secondSubMap}(replacement);
     },
-    [&](CanType type, Type substType, ProtocolDecl *proto) {
-      if (auto replacement = type.transformRec(replaceGenericParameter))
-        return secondSubMap.lookupConformance(replacement->getCanonicalType(),
-                                              proto);
-      if (auto conformance = firstSubMap.lookupConformance(type, proto))
-        return conformance;
-
-      // We might not have enough information in the substitution maps alone.
-      //
-      // Eg,
-      //
-      // class Base<T1> {
-      //   func foo<U1>(_: U1) where T1 : P {}
-      // }
-      //
-      // class Derived<T2> : Base<Foo<T2>> {
-      //   override func foo<U2>(_: U2) where T2 : Q {}
-      // }
-      //
-      // Suppose we're devirtualizing a call to Base.foo() on a value whose
-      // type is known to be Derived<Bar>. We start with substitutions written
-      // in terms of Base.foo()'s generic signature:
-      //
-      // <T1, U1 where T1 : P>
-      // T1 := Foo<Bar>
-      // T1 : P := Foo<Bar> : P
-      //
-      // We want to build substitutions in terms of Derived.foo()'s
-      // generic signature:
-      //
-      // <T2, U2 where T2 : Q>
-      // T2 := Bar
-      // T2 : Q := Bar : Q
-      //
-      // The conformance Bar : Q is difficult to recover in the general case.
-      //
-      // Some combination of storing substitution maps in BoundGenericTypes
-      // as well as for method overrides would solve this, but for now, just
-      // punt to module lookup.
-      if (substType->isTypeParameter())
-        return ProtocolConformanceRef(proto);
-
-      return swift::lookupConformance(substType, proto);
-    });
+    // We might not have enough information in the substitution maps alone.
+    //
+    // Eg,
+    //
+    // class Base<T1> {
+    //   func foo<U1>(_: U1) where T1 : P {}
+    // }
+    //
+    // class Derived<T2> : Base<Foo<T2>> {
+    //   override func foo<U2>(_: U2) where T2 : Q {}
+    // }
+    //
+    // Suppose we're devirtualizing a call to Base.foo() on a value whose
+    // type is known to be Derived<Bar>. We start with substitutions written
+    // in terms of Base.foo()'s generic signature:
+    //
+    // <T1, U1 where T1 : P>
+    // T1 := Foo<Bar>
+    // T1 : P := Foo<Bar> : P
+    //
+    // We want to build substitutions in terms of Derived.foo()'s
+    // generic signature:
+    //
+    // <T2, U2 where T2 : Q>
+    // T2 := Bar
+    // T2 : Q := Bar : Q
+    //
+    // The conformance Bar : Q is difficult to recover in the general case.
+    //
+    // Some combination of storing substitution maps in BoundGenericTypes
+    // as well as for method overrides would solve this, but for now, just
+    // punt to global lookup.
+    LookUpConformanceInModule());
 }
 
 // Start with the substitutions from the apply.

test/SILOptimizer/rdar134732867.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swift-frontend -emit-sil -O %s
+
+public class Base<T> {
+  @inline(never)
+  func f<E>(_: E, _ t: T, _ elt: T.Element) -> Bool where T: Sequence, T.Element: Equatable {
+    var iter = t.makeIterator()
+    return iter.next()! == elt
+  }
+}
+
+public func caller(b: Base<Array<Int>>) -> Bool {
+  return b.f(123, [1, 2, 3], 5)
+}