Add an option to allow space around range formation operators.

Fixes swiftlang#457

Author: dabrahams

Documentation/Configuration.md

@@ -79,6 +79,9 @@ top-level keys and values:
    true, a line break is forced before the "." of the component and after the component's
    closing delimiter (i.e. right paren, right bracket, right brace, etc.).
 
+*  `spacesAroundRangeFormationOperators` _(boolean)_: Determines whether whitespace should be forced
+   before and after the range formation operators `...` and `..<`.
+
 > TODO: Add support for enabling/disabling specific syntax transformations in
 > the pipeline.
 

Sources/SwiftFormatConfiguration/Configuration.swift

@@ -35,6 +35,7 @@ public struct Configuration: Codable, Equatable {
     case fileScopedDeclarationPrivacy
     case indentSwitchCaseLabels
     case rules
+    case spacesAroundRangeFormationOperators
   }
 
   /// The version of this configuration.
@@ -142,6 +143,10 @@ public struct Configuration: Codable, Equatable {
   ///```
   public var indentSwitchCaseLabels = false
 
+  /// Determines whether whitespace should be forced before and after the range formation operators
+  /// `...` and `..<`.
+  public var spacesAroundRangeFormationOperators = false
+
   /// Constructs a Configuration with all default values.
   public init() {
     self.version = highestSupportedConfigurationVersion
@@ -194,6 +199,9 @@ public struct Configuration: Codable, Equatable {
     self.lineBreakAroundMultilineExpressionChainComponents =
       try container.decodeIfPresent(
         Bool.self, forKey: .lineBreakAroundMultilineExpressionChainComponents) ?? false
+    self.spacesAroundRangeFormationOperators =
+      try container.decodeIfPresent(
+        Bool.self, forKey: .spacesAroundRangeFormationOperators) ?? false
     self.fileScopedDeclarationPrivacy =
       try container.decodeIfPresent(
         FileScopedDeclarationPrivacyConfiguration.self, forKey: .fileScopedDeclarationPrivacy)
@@ -226,6 +234,8 @@ public struct Configuration: Codable, Equatable {
     try container.encode(
       lineBreakAroundMultilineExpressionChainComponents,
       forKey: .lineBreakAroundMultilineExpressionChainComponents)
+    try container.encode(
+      spacesAroundRangeFormationOperators, forKey: .spacesAroundRangeFormationOperators)
     try container.encode(fileScopedDeclarationPrivacy, forKey: .fileScopedDeclarationPrivacy)
     try container.encode(indentSwitchCaseLabels, forKey: .indentSwitchCaseLabels)
     try container.encode(rules, forKey: .rules)

Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift

@@ -1763,7 +1763,7 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
 
       let wrapsBeforeOperator = !isAssigningOperator(binOp)
 
-      if shouldRequireWhitespace(around: binOp) {
+      if shouldRequireWhitespace(around: binOp, config: config) {
         if isAssigningOperator(binOp) {
           var beforeTokens: [Token]
 
@@ -3317,20 +3317,24 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
     return nil
   }
 
-  /// Returns a value indicating whether whitespace should be required around the given operator.
+  /// Returns a value indicating whether whitespace should be required around the given operator,
+  /// for the given configuration.
   ///
   /// If spaces are not required (for example, range operators), then the formatter will also forbid
   /// breaks around the operator. This is to prevent situations where a break could occur before an
   /// unspaced operator (e.g., turning `0...10` into `0<newline>...10`), which would be a breaking
   /// change because it would treat it as a prefix operator `...10` instead of an infix operator.
-  private func shouldRequireWhitespace(around operatorExpr: ExprSyntax) -> Bool {
+  private func shouldRequireWhitespace(
+    around operatorExpr: ExprSyntax, config: Configuration) -> Bool
+  {
     // Note that we look at the operator itself to make this determination, not the token kind.
     // 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.self) {
       let token = binaryOperator.operatorToken
-      if let precedence = operatorContext.infixOperator(named: token.text)?.precedenceGroup,
-        precedence === operatorContext.precedenceGroup(named: .rangeFormation)
+      if !config.spacesAroundRangeFormationOperators,
+         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, followed by a prefix operator, or

Tests/SwiftFormatPrettyPrintTests/BinaryOperatorExprTests.swift

@@ -1,3 +1,5 @@
+import SwiftFormatConfiguration
+
 final class BinaryOperatorExprTests: PrettyPrintTestCase {
   func testNonRangeFormationOperatorsAreSurroundedByBreaks() {
     let input =
@@ -26,7 +28,7 @@ final class BinaryOperatorExprTests: PrettyPrintTestCase {
     assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
   }
 
-  func testRangeFormationOperatorsAreCompactedWhenPossible() {
+  func testRangeFormationOperatorCompaction_noSpacesAroundRangeFormation() {
     let input =
       """
       x = 1...100
@@ -48,7 +50,38 @@ final class BinaryOperatorExprTests: PrettyPrintTestCase {
 
       """
 
-    assertPrettyPrintEqual(input: input, expected: expected, linelength: 80)
+    var configuration = Configuration()
+    configuration.spacesAroundRangeFormationOperators = false
+    assertPrettyPrintEqual(
+      input: input, expected: expected, linelength: 80, configuration: configuration)
+  }
+
+  func testRangeFormationOperatorCompaction_spacesAroundRangeFormation() {
+    let input =
+      """
+      x = 1...100
+      x = 1..<100
+      x = (1++)...(-100)
+      x = 1 ... 100
+      x = 1 ..< 100
+      x = (1++) ... (-100)
+      """
+
+    let expected =
+      """
+      x = 1 ... 100
+      x = 1 ..< 100
+      x = (1++) ... (-100)
+      x = 1 ... 100
+      x = 1 ..< 100
+      x = (1++) ... (-100)
+
+      """
+
+    var configuration = Configuration()
+    configuration.spacesAroundRangeFormationOperators = true
+    assertPrettyPrintEqual(
+      input: input, expected: expected, linelength: 80, configuration: configuration)
   }
 
   func testRangeFormationOperatorsAreNotCompactedWhenFollowingAPostfixOperator() {