Merge pull request #91 from allevato/operator-scrunching

Fix scrunching of range operators.

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),
     ]
 }