Merge pull request #14318 from xedin/rdar-36838495-5.0

Author: swift-ci

lib/Sema/CSSolver.cpp

@@ -1788,9 +1788,10 @@ static bool shouldSkipDisjunctionChoice(ConstraintSystem &cs,
     // Let's skip generic overload choices only in case if
     // non-generic score indicates that there were no forced
     // unwrappings of optional(s), no unavailable overload
-    // choices present in the solution, and no fixes required.
-    if (score[SK_ForceUnchecked] == 0 && score[SK_Unavailable] == 0
-        && score[SK_Fix] == 0)
+    // choices present in the solution, no fixes required,
+    // and there are no non-trivial function conversions.
+    if (score[SK_ForceUnchecked] == 0 && score[SK_Unavailable] == 0 &&
+        score[SK_Fix] == 0 && score[SK_FunctionConversion] == 0)
       return true;
   }
 

lib/Sema/ConstraintGraph.cpp

@@ -675,13 +675,39 @@ bool ConstraintGraph::contractEdges() {
 
         auto isParamBindingConstraint = kind == ConstraintKind::BindParam;
 
-        // If the parameter is allowed to bind to `inout` let's not
-        // try to contract the edge connecting parameter declaration to
-        // it's use in the body. If parameter declaration is bound to
-        // `inout` it's use has to be bound to `l-value`, which can't
-        // happen once equivalence classes of parameter and argument are merged.
-        if (isParamBindingConstraint && tyvar1->getImpl().canBindToInOut())
-          continue;
+        // If the argument is allowed to bind to `inout`, in general,
+        // it's invalid to contract the edge between argument and parameter,
+        // but if we can prove that there are no possible bindings
+        // which result in attempt to bind `inout` type to argument
+        // type variable, we should go ahead and allow (temporary)
+        // contraction, because that greatly helps with performance.
+        // Such action is valid because argument type variable can
+        // only get its bindings from related overload, which gives
+        // us enough information to decided on l-valueness.
+        if (isParamBindingConstraint && tyvar1->getImpl().canBindToInOut()) {
+          bool isNotContractable = true;
+          if (auto bindings = CS.getPotentialBindings(tyvar1)) {
+            for (auto &binding : bindings.Bindings) {
+              auto type = binding.BindingType;
+              isNotContractable = type.findIf([&](Type nestedType) -> bool {
+                if (auto tv = nestedType->getAs<TypeVariableType>()) {
+                  if (!tv->getImpl().mustBeMaterializable())
+                    return true;
+                }
+
+                return nestedType->is<InOutType>();
+              });
+
+              // If there is at least one non-contractable binding, let's
+              // not risk contracting this edge.
+              if (isNotContractable)
+                break;
+            }
+          }
+
+          if (isNotContractable)
+            continue;
+        }
 
         auto rep1 = CS.getRepresentative(tyvar1);
         auto rep2 = CS.getRepresentative(tyvar2);

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

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
+// REQUIRES: tools-release,no_asserts
+
+struct T {
+  enum B {
+    case a
+    case b
+  }
+
+  let name: String
+  let b: B
+}
+
+struct A {
+  enum C {
+    case a
+    case b
+    case c
+  }
+
+  let name: String
+  let t: T
+  let c: C
+
+  var isX: Bool {
+    return self.t.b == .a
+  }
+}
+
+let x: [String: A] = [:]
+let _ = x.values.filter { $0.isX }
+                .filter { $0.t.b != .a }
+                .filter { $0.c == .a || $0.c == .b }
+                .filter { $0.isX }
+                .filter { $0.t.b != .a }
+                .sorted { $0.name < $1.name }