diff --git a/lib/Sema/CSOptimizer.cpp b/lib/Sema/CSOptimizer.cpp
index 6e31d135b0dd4..702d5acfb3075 100644
--- a/lib/Sema/CSOptimizer.cpp
+++ b/lib/Sema/CSOptimizer.cpp
@@ -260,13 +260,6 @@ static bool isStandardInfixLogicalOperator(Constraint *disjunction) {
   return false;
 }
 
-static bool isOperatorNamed(Constraint *disjunction, StringRef name) {
-  auto *choice = disjunction->getNestedConstraints()[0];
-  if (auto *decl = getOverloadChoiceDecl(choice))
-    return decl->isOperator() && decl->getBaseIdentifier().is(name);
-  return false;
-}
-
 static bool isArithmeticOperator(ValueDecl *decl) {
   return decl->isOperator() && decl->getBaseIdentifier().isArithmeticOperator();
 }
@@ -1022,19 +1015,6 @@ static void determineBestChoicesInContext(
                                            optionals.size());
             types.push_back({type,
                              /*fromLiteral=*/true});
-          } else if (literal.first ==
-                         cs.getASTContext().getProtocol(
-                             KnownProtocolKind::ExpressibleByNilLiteral) &&
-                     literal.second.IsDirectRequirement) {
-            // `==` and `!=` operators have special overloads that accept `nil`
-            // as `_OptionalNilComparisonType` which is preferred over a
-            // generic form `(T?, T?)`.
-            if (isOperatorNamed(disjunction, "==") ||
-                isOperatorNamed(disjunction, "!=")) {
-              auto nilComparisonTy =
-                  cs.getASTContext().get_OptionalNilComparisonTypeType();
-              types.push_back({nilComparisonTy, /*fromLiteral=*/true});
-            }
           }
         }
 
diff --git a/test/Constraints/rdar158063151.swift b/test/Constraints/rdar158063151.swift
new file mode 100644
index 0000000000000..ece6137a738c9
--- /dev/null
+++ b/test/Constraints/rdar158063151.swift
@@ -0,0 +1,16 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+// Make sure that the type-checker selects an `Equatable.==` instead of one from stdlib that takes _OptionalNilComparisonType
+
+struct Value: Equatable, ExpressibleByNilLiteral {
+  init(nilLiteral: ()) {
+  }
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s13rdar1580631514test1vyAA5ValueV_tF : $@convention(thin) (Value) -> ()
+// function_ref static Value.__derived_struct_equals(_:_:)
+// CHECK: [[EQUALS_REF:%.*]] = function_ref @$s13rdar1580631515ValueV23__derived_struct_equalsySbAC_ACtFZ
+// CHECK-NEXT: apply [[EQUALS_REF]](%0, {{.*}})
+func test(v: Value) {
+  _ = v == nil
+}
diff --git a/test/SILOptimizer/infinite_recursion.swift b/test/SILOptimizer/infinite_recursion.swift
index 11e051394676e..943863d4b860b 100644
--- a/test/SILOptimizer/infinite_recursion.swift
+++ b/test/SILOptimizer/infinite_recursion.swift
@@ -282,7 +282,7 @@ public class U {
 }
 
 func == (l: S?, r: S?) -> Bool {
-  if l == nil && r == nil { return true }
+  if l == nil && r == nil { return true } // expected-warning {{function call causes an infinite recursion}}
   guard let l = l, let r = r else { return false }
   return l === r
 }
diff --git a/validation-test/Sema/type_checker_perf/fast/rdar17170728.swift b/validation-test/Sema/type_checker_perf/slow/rdar17170728.swift
similarity index 74%
rename from validation-test/Sema/type_checker_perf/fast/rdar17170728.swift
rename to validation-test/Sema/type_checker_perf/slow/rdar17170728.swift
index 1e64e4194e4b6..62c2bb2ea367b 100644
--- a/validation-test/Sema/type_checker_perf/fast/rdar17170728.swift
+++ b/validation-test/Sema/type_checker_perf/slow/rdar17170728.swift
@@ -5,6 +5,7 @@ let i: Int? = 1
 let j: Int?
 let k: Int? = 2
 
+// expected-error@+1 {{the compiler is unable to type-check this expression in reasonable time}}
 let _ = [i, j, k].reduce(0 as Int?) {
   $0 != nil && $1 != nil ? $0! + $1! : ($0 != nil ? $0! : ($1 != nil ? $1! : nil))
 }