Sema: Don't attempt deep equality if we're also attempting optional-to-optional

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -8100,6 +8100,38 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   if (conversionsOrFixes.empty())
     return getTypeMatchFailure(locator);
 
+  std::optional<ConversionRestrictionKind> redundantDeepEquality;
+  bool sawDeepEquality = false;
+
+  for (auto potential : conversionsOrFixes) {
+    if (auto restriction = potential.getRestriction()) {
+      switch (*restriction) {
+      case ConversionRestrictionKind::DeepEquality:
+        sawDeepEquality = true;
+        break;
+      case ConversionRestrictionKind::OptionalToOptional:
+        redundantDeepEquality = *restriction;
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  auto favoredRestriction = ConversionRestrictionKind::DeepEquality;
+  if (sawDeepEquality && redundantDeepEquality) {
+    favoredRestriction = *redundantDeepEquality;
+
+    conversionsOrFixes.erase(
+        llvm::remove_if(conversionsOrFixes,
+                        [&](RestrictionOrFix &potential) {
+                          if (auto restriction = potential.getRestriction())
+                            return *restriction == ConversionRestrictionKind::DeepEquality;
+                          return false;
+                        }),
+        conversionsOrFixes.end());
+  }
+
   // Where there is more than one potential conversion, create a disjunction
   // so that we'll explore all of the options.
   if (conversionsOrFixes.size() > 1) {
@@ -8119,7 +8151,7 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
           Constraint::createRestricted(*this, constraintKind, *restriction,
                                        type1, type2, fixedLocator));
 
-        if (constraints.back()->getKind() == ConstraintKind::Bind)
+        if (*restriction == favoredRestriction)
           constraints.back()->setFavored();
 
         continue;
@@ -14482,8 +14514,6 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   // also:
   //   T <c U ===> T? <c U!
   case ConversionRestrictionKind::OptionalToOptional: {
-    addContextualScore();
-
     assert(matchKind >= ConstraintKind::Subtype);
     if (auto generic1 = type1->getAs<BoundGenericType>()) {
       if (auto generic2 = type2->getAs<BoundGenericType>()) {

test/Constraints/closures.swift

@@ -1305,3 +1305,13 @@ do {
         })
   }
 }
+
+func rdar143338891() {
+  func takesAny(_: Any?) {}
+
+  class Test {
+    func test() {
+      _ = { [weak self] in takesAny(self) }
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift -solver-scope-threshold=40000
+
+func f(str1: String, str2: String) -> (Any.Type)? {
+    return _typeByName(str1)
+        ?? _typeByName(str2)
+        ?? _typeByName("a.\(str2)")
+        ?? _typeByName("b.\(str2)")
+        ?? _typeByName("c.\(str2)")
+        ?? _typeByName("d.\(str2)")
+        ?? _typeByName("e.\(str2)")
+        ?? _typeByName("f.\(str2)")
+}