[CSOptimizer] Prefer logical infix operator if it has smaller overload set

Infix logical operators are usually not overloaded and don't
form disjunctions, but when they do, let's prefer them over
other operators when they have fewer choices because it helps
to split operator chains.

Author: xedin

include/swift/AST/Identifier.h

@@ -140,6 +140,10 @@ class Identifier {
     return is("??");
   }
 
+  // Returns whether this is a standard infix logical operator,
+  // such as '&&', '||'.
+  bool isStandardInfixLogicalOperator() const { return is("&&") || is("||"); }
+
   /// isOperatorStartCodePoint - Return true if the specified code point is a
   /// valid start of an operator.
   static bool isOperatorStartCodePoint(uint32_t C) {

lib/Sema/CSOptimizer.cpp

@@ -251,6 +251,14 @@ static bool isStandardComparisonOperator(Constraint *disjunction) {
   return false;
 }
 
+static bool isStandardInfixLogicalOperator(Constraint *disjunction) {
+  auto *choice = disjunction->getNestedConstraints()[0];
+  if (auto *decl = getOverloadChoiceDecl(choice))
+    return decl->isOperator() &&
+           decl->getBaseIdentifier().isStandardInfixLogicalOperator();
+  return false;
+}
+
 static bool isOperatorNamed(Constraint *disjunction, StringRef name) {
   auto *choice = disjunction->getNestedConstraints()[0];
   if (auto *decl = getOverloadChoiceDecl(choice))
@@ -1856,6 +1864,16 @@ ConstraintSystem::selectDisjunction() {
         bool isFirstOperator = isOperatorDisjunction(first);
         bool isSecondOperator = isOperatorDisjunction(second);
 
+        // Infix logical operators are usually not overloaded and don't
+        // form disjunctions, but when they do, let's prefer them over
+        // other operators when they have fewer choices because it helps
+        // to split operator chains.
+        if (isFirstOperator && isSecondOperator) {
+          if (isStandardInfixLogicalOperator(first) !=
+              isStandardInfixLogicalOperator(second))
+            return firstActive < secondActive;
+        }
+
         // Not all of the non-operator disjunctions are supported by the
         // ranking algorithm, so to prevent eager selection of operators
         // when nothing concrete is known about them, let's reset the score

validation-test/Sema/type_checker_perf/fast/logical_infix_operator_chains.swift.gyb

@@ -0,0 +1,51 @@
+// RUN: %scale-test --begin 1 --end 20 --step 1 --select NumLeafScopes %s
+// REQUIRES: asserts,no_asan
+
+struct Predicate<T> : Equatable {}
+
+func ||<T>(_: Predicate<T>, _: Predicate<T>) -> Predicate<T> {
+  .init()
+}
+
+func !=<Value, Operand>(_: Operand, _: Operand) -> Predicate<Value> where Operand : Equatable {
+  .init()
+}
+
+func !=<Value, Operand>(_: Operand, _: KeyPath<Value, Operand>) -> Predicate<Value> where Operand : Equatable {
+  .init()
+}
+
+func !=<Value, Operand>(_: KeyPath<Value, Operand>, _: Operand) -> Predicate<Value> where Operand : Equatable {
+  .init()
+}
+
+func !=<Value, Operand>(_: KeyPath<Value, Operand>, _: KeyPath<Value, Operand>) -> Predicate<Value> where Operand : Equatable {
+  .init()
+}
+
+enum Format : UInt, Equatable {
+case simple = 0
+}
+
+struct Parameter {
+  struct Buffers {
+    struct Data {
+      let format: Format
+    }
+
+    let data: Data?
+  }
+
+  var buffers: Buffers
+}
+
+func test(arr: [Parameter]) {
+  for p in arr {
+    if (p.buffers.data != nil && p.buffers.data!.format != .simple) ||
+%for i in range(1, N):
+       (p.buffers.data != nil && p.buffers.data!.format != .simple) ||
+%end
+       (p.buffers.data != nil && p.buffers.data!.format != .simple) {
+    }
+  }
+}