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

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -8158,6 +8158,41 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   if (conversionsOrFixes.empty())
     return getTypeMatchFailure(locator);
 
+  auto favoredRestriction = ConversionRestrictionKind::DeepEquality;
+  if (!(shouldAttemptFixes() ||
+        getASTContext().TypeCheckerOpts.DisableOptimizedRestrictions)) {
+    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;
+        }
+      }
+    }
+
+    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) {
@@ -8177,7 +8212,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;
@@ -14627,7 +14662,9 @@ ConstraintSystem::simplifyRestrictedConstraintImpl(
   // also:
   //   T <c U ===> T? <c U!
   case ConversionRestrictionKind::OptionalToOptional: {
-    addContextualScore();
+    if (shouldAttemptFixes() ||
+        getASTContext().TypeCheckerOpts.DisableOptimizedRestrictions)
+      addContextualScore();
 
     assert(matchKind >= ConstraintKind::Subtype);
     if (auto generic1 = type1->getAs<BoundGenericType>()) {

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)")
+}

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

@@ -46,8 +46,7 @@ struct Options {
   static func create(_ project: String?) -> (String?) -> (String) -> (String) -> (String?) -> (String?) -> (String?) -> (String?) -> (Bool) -> ([String]) -> Options { fatalError() }
 
   static func evaluate(_ mode: CommandMode) -> Result<Options, ConcreteError> {
-    let defaultBuildDirectory = ""
-    return create // expected-error {{the compiler is unable to type-check this expression in reasonable time}}
+    return create
       <*> mode <| Option(key: "", defaultValue: nil, usage: "")
       <*> mode <| Option(key: "", defaultValue: nil, usage: "")
       <*> mode <| Option(key: "", defaultValue: FileManager.default.currentDirectoryPath, usage: "")