Fix scrunching of range operators.

We can't unconditionally remove all whitespace around range operators
when they are preceded by a postfix operator or followed by a
postfix operator; the parser greedily treats the combined string
as a single operator.

We still remove whitespace around range operators when possible, but
rather than try to strictly enforce the lack of whitespace in all cases
through more clever and potentially disruptive transformations (like
surrounding the operands by parentheses), we just keep the whitespace
when we can't remove it.

Fixes SR-11798.

Author: allevato

Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift

@@ -2445,13 +2445,24 @@ private final class TokenStreamCreator: SyntaxVisitor {
     // The token kind (spaced or unspaced operator) represents how the *user* wrote it, and we want
     // to ignore that and apply our own rules.
     if let binaryOperator = operatorExpr as? BinaryOperatorExprSyntax {
-      let operatorText = binaryOperator.operatorToken.text
-      if let precedence = operatorContext.infixOperator(named: operatorText)?.precedenceGroup,
+      let token = binaryOperator.operatorToken
+      if let precedence = operatorContext.infixOperator(named: token.text)?.precedenceGroup,
         precedence === operatorContext.precedenceGroup(named: .rangeFormation)
       {
+        // We want to omit whitespace around range formation operators if possible. We can't do this
+        // if the token is either preceded by a postfix operator or followed by a prefix operator---
+        // removing the spaces in those situations would cause the parser to greedily treat the
+        // combined sequence of operator characters as a single operator.
+        if case .postfixOperator? = token.previousToken?.tokenKind { return true }
+        if case .prefixOperator? = token.nextToken?.tokenKind { return true }
         return false
       }
     }
+
+    // For all other operators, we want to require whitespace on each side. That's always safe, so
+    // we don't need to be concerned about neighboring operator tokens. For example, we don't need
+    // to be concerned about the user writing "4+-5" when they meant "4 + -5", because Swift would
+    // always parse the former as "4 +- 5".
     return true
   }
 }

Tests/SwiftFormatPrettyPrintTests/BinaryOperatorExprTests.swift

@@ -1,16 +1,161 @@
 public class BinaryOperatorExprTests: PrettyPrintTestCase {
-  public func testOperatorSpacing() {
+
+  public func testNonRangeFormationOperatorsAreSurroundedByBreaks() {
+    let input =
+      """
+      x=1+8-9  ^*^  5*4/10
+      """
+
+    let expected80 =
+      """
+      x = 1 + 8 - 9 ^*^ 5 * 4 / 10
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected80, linelength: 80)
+
+    let expected10 =
+      """
+      x = 1 + 8
+        - 9
+        ^*^ 5
+        * 4 / 10
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
+  }
+
+  public func testRangeFormationOperatorsAreCompactedWhenPossible() {
     let input =
       """
-      x=1+8-9  ..<  5*4/10
+      x = 1...100
+      x = 1..<100
+      x = (1++)...(-100)
+      x = 1 ... 100
+      x = 1 ..< 100
+      x = (1++) ... (-100)
       """
 
     let expected =
       """
-      x = 1 + 8 - 9..<5 * 4 / 10
+      x = 1...100
+      x = 1..<100
+      x = (1++)...(-100)
+      x = 1...100
+      x = 1..<100
+      x = (1++)...(-100)
 
       """
 
     assertPrettyPrintEqual(input: input, expected: expected, linelength: 80)
   }
+
+  public func testRangeFormationOperatorsAreNotCompactedWhenFollowingAPostfixOperator() {
+    let input =
+      """
+      x = 1++ ... 100
+      x = 1-- ..< 100
+      x = 1++   ...   100
+      x = 1--   ..<   100
+      """
+
+    let expected80 =
+      """
+      x = 1++ ... 100
+      x = 1-- ..< 100
+      x = 1++ ... 100
+      x = 1-- ..< 100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected80, linelength: 80)
+
+    let expected10 =
+      """
+      x = 1++
+        ... 100
+      x = 1--
+        ..< 100
+      x = 1++
+        ... 100
+      x = 1--
+        ..< 100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
+  }
+
+  public func testRangeFormationOperatorsAreNotCompactedWhenPrecedingAPrefixOperator() {
+    let input =
+      """
+      x = 1 ... -100
+      x = 1 ..< -100
+      x = 1   ...   √100
+      x = 1   ..<   √100
+      """
+
+    let expected80 =
+      """
+      x = 1 ... -100
+      x = 1 ..< -100
+      x = 1 ... √100
+      x = 1 ..< √100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected80, linelength: 80)
+
+    let expected10 =
+      """
+      x = 1
+        ... -100
+      x = 1
+        ..< -100
+      x = 1
+        ... √100
+      x = 1
+        ..< √100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
+  }
+
+  public func testRangeFormationOperatorsAreNotCompactedWhenUnaryOperatorsAreOnEachSide() {
+    let input =
+      """
+      x = 1++ ... -100
+      x = 1-- ..< -100
+      x = 1++   ...   √100
+      x = 1--   ..<   √100
+      """
+
+    let expected80 =
+      """
+      x = 1++ ... -100
+      x = 1-- ..< -100
+      x = 1++ ... √100
+      x = 1-- ..< √100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected80, linelength: 80)
+
+    let expected10 =
+      """
+      x = 1++
+        ... -100
+      x = 1--
+        ..< -100
+      x = 1++
+        ... √100
+      x = 1--
+        ..< √100
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
+  }
 }

Tests/SwiftFormatPrettyPrintTests/XCTestManifests.swift

@@ -89,7 +89,11 @@ extension BinaryOperatorExprTests {
     //   `swift test --generate-linuxmain`
     // to regenerate.
     static let __allTests__BinaryOperatorExprTests = [
-        ("testOperatorSpacing", testOperatorSpacing),
+        ("testNonRangeFormationOperatorsAreSurroundedByBreaks", testNonRangeFormationOperatorsAreSurroundedByBreaks),
+        ("testRangeFormationOperatorsAreCompactedWhenPossible", testRangeFormationOperatorsAreCompactedWhenPossible),
+        ("testRangeFormationOperatorsAreNotCompactedWhenFollowingAPostfixOperator", testRangeFormationOperatorsAreNotCompactedWhenFollowingAPostfixOperator),
+        ("testRangeFormationOperatorsAreNotCompactedWhenPrecedingAPrefixOperator", testRangeFormationOperatorsAreNotCompactedWhenPrecedingAPrefixOperator),
+        ("testRangeFormationOperatorsAreNotCompactedWhenUnaryOperatorsAreOnEachSide", testRangeFormationOperatorsAreNotCompactedWhenUnaryOperatorsAreOnEachSide),
     ]
 }