[ConstraintSystem] Bind external closure parameter type to a concrete contextual type

Performance optimization.

If there is a concrete contextual type we could use, let's bind
it to the external type right away because internal type has to
be equal to that type anyway (through `BindParam` on external type
i.e. <internal> bind param <external> conv <concrete contextual>).

```swift
func test(_: ([String]) -> Void) {}

test { $0 == ["a", "b"] }
```

Without this optimization for almost all overloads of `==`
expect for one on `Equatable` and one on `Array` solver would
have to repeatedly try the same `[String]` type for `$0` and
fail, which does nothing expect hurts performance.

Resolves: rdar://19836070
Resolves: rdar://19357292
Resolves: rdar://75476311

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -8354,17 +8354,53 @@ static Type getOpenedResultBuilderTypeFor(ConstraintSystem &cs,
 bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
                                       Type contextualType,
                                       ConstraintLocatorBuilder locator) {
+  auto *closureLocator = typeVar->getImpl().getLocator();
+  auto *closure = castToExpr<ClosureExpr>(closureLocator->getAnchor());
+  auto *inferredClosureType = getClosureType(closure);
+
   auto getContextualParamAt =
-      [&contextualType](unsigned index) -> Optional<AnyFunctionType::Param> {
+      [&contextualType, &inferredClosureType](
+          unsigned index) -> Optional<AnyFunctionType::Param> {
     auto *fnType = contextualType->getAs<FunctionType>();
-    return fnType && fnType->getNumParams() > index
-               ? fnType->getParams()[index]
-               : Optional<AnyFunctionType::Param>();
+    if (!fnType)
+      return None;
+
+    auto numContextualParams = fnType->getNumParams();
+    if (numContextualParams != inferredClosureType->getNumParams() ||
+        numContextualParams <= index)
+      return None;
+
+    return fnType->getParams()[index];
   };
 
-  auto *closureLocator = typeVar->getImpl().getLocator();
-  auto *closure = castToExpr<ClosureExpr>(closureLocator->getAnchor());
-  auto *inferredClosureType = getClosureType(closure);
+  // Check whether given contextual parameter type could be
+  // used to bind external closure parameter type.
+  auto isSuitableContextualType = [](Type contextualTy) {
+    // We need to wait until contextual type
+    // is fully resolved before binding it.
+    if (contextualTy->isTypeVariableOrMember())
+      return false;
+
+    // If contextual type has an error, let's wait for inference,
+    // otherwise contextual would interfere with diagnostics.
+    if (contextualTy->hasError())
+      return false;
+
+    if (isa<TypeAliasType>(contextualTy.getPointer())) {
+      auto underlyingTy = contextualTy->getDesugaredType();
+      // FIXME: typealias pointing to an existential type is special
+      // because if the typealias has type variables then we'd end up
+      // opening existential from a type with unresolved generic
+      // parameter(s), which CSApply can't currently simplify while
+      // building type-checked AST because `OpenedArchetypeType` doesn't
+      // propagate flags. Example is as simple as `{ $0.description }`
+      // where `$0` is `Error` that inferred from a (generic) typealias.
+      if (underlyingTy->isExistentialType() && contextualTy->hasTypeVariable())
+        return false;
+    }
+
+    return true;
+  };
 
   // Determine whether a result builder will be applied.
   auto resultBuilderType = getOpenedResultBuilderTypeFor(*this, locator);
@@ -8456,6 +8492,24 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
           param.isVariadic() ? ArraySliceType::get(typeVar) : Type(typeVar);
 
       auto externalType = param.getOldType();
+
+      // Performance optimization.
+      //
+      // If there is a concrete contextual type we could use, let's bind
+      // it to the external type right away because internal type has to
+      // be equal to that type anyway (through `BindParam` on external type
+      // i.e. <internal> bind param <external> conv <concrete contextual>).
+      //
+      // Note: it's correct to avoid doing this, but it would result
+      // in (a lot) more checking since solver would have to re-discover,
+      // re-attempt and fail parameter type while solving for overloaded
+      // choices in the body.
+      if (auto contextualParam = getContextualParamAt(i)) {
+        auto paramTy = simplifyType(contextualParam->getOldType());
+        if (isSuitableContextualType(paramTy))
+          addConstraint(ConstraintKind::Bind, externalType, paramTy, paramLoc);
+      }
+
       if (oneWayConstraints) {
         addConstraint(
             ConstraintKind::OneWayBindParam, typeVar, externalType, paramLoc);

test/Constraints/closures.swift

@@ -377,7 +377,7 @@ func rdar21078316() {
 
 // <rdar://problem/20978044> QoI: Poor diagnostic when using an incorrect tuple element in a closure
 var numbers = [1, 2, 3]
-zip(numbers, numbers).filter { $0.2 > 1 }  // expected-error {{value of tuple type '(Int, Int)' has no member '2'}}
+zip(numbers, numbers).filter { $0.2 > 1 }  // expected-error {{value of tuple type '(Array<Int>.Element, Array<Int>.Element)' has no member '2'}}
 
 
 

validation-test/Sema/type_checker_perf/slow/rdar19357292.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar19357292.swift

@@ -4,6 +4,5 @@
 func test(strings: [String]) {
   for string in strings {
     let _ = string.split(omittingEmptySubsequences: false) { $0 == "C" || $0 == "D" || $0 == "H" || $0 == "S"}
-    // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
   }
 }

validation-test/Sema/type_checker_perf/slow/rdar19836070.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar19836070.swift

@@ -1,7 +1,6 @@
 // RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
 // REQUIRES: tools-release,no_asan
 
-// expected-error@+1 {{the compiler is unable to type-check this expression in reasonable time}}
 let _: (Character) -> Bool = { c in
   ("a" <= c && c <= "z") || ("A" <= c && c <= "Z") || c == "_"
 }

validation-test/Sema/type_checker_perf/fast/rdar75476311.swift

@@ -0,0 +1,32 @@
+// RUN: %target-typecheck-verify-swift -target x86_64-apple-macosx10.15 -solver-expression-time-threshold=1 -swift-version 5
+// REQUIRES: tools-release,no_asan,objc_interop
+// REQUIRES: OS=macosx
+
+import Combine
+import Foundation
+import simd
+
+class Entry : NSObject {}
+
+class Query : NSObject {
+}
+
+class Test {
+  typealias QueryPublisher = AnyPublisher<Query, Never>
+
+  @Published var tokens: [Entry] = []
+  @Published var text: String = ""
+
+  var test: QueryPublisher {
+    $tokens
+     .combineLatest($text)
+     .debounce(for: 0.2, scheduler: RunLoop.main)
+     .removeDuplicates(by: { (first, second) -> Bool in
+       first.0 == second.0 && first.1 == second.1 // Ok (lot of overloads here) and first `==` is different from second
+     })
+     .map { _ in
+       Query()
+     }
+     .eraseToAnyPublisher()
+  }
+}

validation-test/Sema/type_checker_perf/slow/mixed_string_array_addition.swift

@@ -6,7 +6,7 @@ func test(str: String, properties: [String]) {
   // expected-error@+1 {{the compiler is unable to type-check this expression in reasonable time}}
   method(str + "" + str + "") {
     properties.map { param in
-      "" + param + "" + param + ""
+      "" + param + "" + param + "" + param + ""
     } + [""]
   }
 }