Merge pull request swiftlang#82869 from xedin/logic-infix-operators-perf

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

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