Implement use early exits (swiftlang#75)

Author: LaurenWhite

Diff for: tools/swift-format/Sources/Rules/ReindentBlock.swift

@@ -0,0 +1,53 @@
+import Foundation
+import SwiftSyntax
+
+/// Rewriter that changes the indentation of a given code block with the
+/// provided indentation adjustment.
+private final class ReindentBlock: SyntaxRewriter {
+  let adjustment: Int
+  
+  init(adjustment: Int) {
+    self.adjustment = adjustment
+  }
+  
+  override func visit(_ token: TokenSyntax) -> Syntax {
+    guard token.leadingTrivia.containsNewlines else { return token }
+    
+    var newTrivia: [TriviaPiece] = []
+    var previousIsNewline = false
+    
+    for piece in token.leadingTrivia {
+      if case .newlines = piece {
+        newTrivia.append(piece)
+        previousIsNewline = true
+        continue
+      } else {
+        guard previousIsNewline else { newTrivia.append(piece); continue }
+        if case .spaces(let n) = piece {
+          // Replace current indent
+          let newIndent = n + adjustment
+          let newPiece = (newIndent > 0) ? Trivia.spaces(newIndent) : .spaces(0)
+          newTrivia.append(contentsOf: newPiece)
+        } else {
+          // Insert new indent at front
+          let newPiece = (adjustment > 0) ? Trivia.spaces(adjustment) : .spaces(0)
+          // TODO(laurenwhite): warning for indentation without enough spaces to be adjusted?
+          newTrivia.append(contentsOf: newPiece)
+          newTrivia.append(piece)
+        }
+        previousIsNewline = false
+      }
+    }
+    return token.withLeadingTrivia(Trivia(pieces: newTrivia))
+  }
+  
+}
+
+/// Replaces the given block with new indentation from the provided adjustment.
+/// - Parameters:
+///   - block: The code block whose containing items will be reindented
+///   - adjustment: The number of spaces by which the current indentation will be moved. This
+///                 integer may be negative (moves left) or positive (moves right).
+func reindentBlock(block: CodeBlockSyntax, adjustment: Int) -> Syntax {
+  return ReindentBlock(adjustment: adjustment).visit(block)
+}

Diff for: tools/swift-format/Sources/Rules/UseEarlyExits.swift

@@ -15,5 +15,64 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#guards-for-early-exits
 public final class UseEarlyExits: SyntaxFormatRule {
+  
+  public override func visit(_ node: CodeBlockSyntax) -> Syntax {
+    
+    var newItems: [CodeBlockItemSyntax] = []
+    for statement in node.statements {
+      guard let ifStmt = statement.item as? IfStmtSyntax else { return node }
+      guard let elseStmt = ifStmt.elseBody else { return node }
+      guard let elseBody = elseStmt as? CodeBlockSyntax else { return node }
 
+      if elseContainsControlStmt(elseStmt: elseStmt) {
+        diagnose(.useGuardStmt, on: ifStmt)
+        guard let moveDeletedIfCode = visit(
+          ifStmt.body.withLeftBrace(nil).withRightBrace(nil)) as? CodeBlockSyntax else { continue }
+        guard let moveElseBody = visit(elseBody) as? CodeBlockSyntax else { continue }
+        
+        let ifConditions = ifStmt.conditions
+        let formattedGuardKeyword = SyntaxFactory.makeGuardKeyword(
+          leadingTrivia: ifStmt.ifKeyword.leadingTrivia,
+          trailingTrivia: .spaces(1))
+        let newGuardStmt = SyntaxFactory.makeGuardStmt(
+          guardKeyword: formattedGuardKeyword,
+          conditions: ifConditions,
+          elseKeyword: SyntaxFactory.makeElseKeyword(trailingTrivia: .spaces(1)),
+          body: moveElseBody)
+        newItems.append(
+          SyntaxFactory.makeCodeBlockItem(item: newGuardStmt,
+                                          semicolon: nil,
+                                          errorTokens: nil)
+        )
+        newItems.append(
+          SyntaxFactory.makeCodeBlockItem(item: moveDeletedIfCode,
+                                          semicolon: nil,
+                                          errorTokens: nil)
+        )
+      }
+    }
+
+    let newNode = node.withStatements(SyntaxFactory.makeCodeBlockItemList(newItems))
+    return super.visit(newNode)
+  }
+
+  func elseContainsControlStmt(elseStmt: Syntax) -> Bool {
+    for child in elseStmt.children {
+      guard let codeBlockList = child as? CodeBlockItemListSyntax else { continue }
+      guard let last = codeBlockList.child(at: codeBlockList.count - 1) as?
+        CodeBlockItemSyntax else { continue }
+
+      switch last.item {
+      case is ReturnStmtSyntax, is ThrowStmtSyntax, is BreakStmtSyntax, is ContinueStmtSyntax:
+        return true
+      default:
+        continue
+      }
+    }
+    return false
+  }
+}
+
+extension Diagnostic.Message {
+  static let useGuardStmt = Diagnostic.Message(.warning, "replace with guard statement")
 }

Diff for: tools/swift-format/Tests/SwiftFormatTests/UseEarlyExitsTests.swift

@@ -0,0 +1,70 @@
+import Foundation
+import XCTest
+import SwiftSyntax
+
+@testable import Rules
+
+public class UseEarlyExitsTests: DiagnosingTestCase {
+  public func testIfToGuardStmtSwitch() {
+    XCTAssertFormatting(
+      UseEarlyExits.self,
+      input: """
+             func discombobulate(_ values: [Int]) throws -> Int {
+
+               // Comment 1
+
+               /*Comment 2*/ if let first = values.first {
+                 // Comment 3
+
+                 /// Doc comment
+                 if first >= 0 {
+                   // Comment 4
+                   var result = 0
+                   for value in values {
+                     result += invertedCombobulatoryFactor(of: value)
+                   }
+                   return result
+                 } else {
+                   print("Can't have negative energy")
+                   throw DiscombobulationError.negativeEnergy
+                 }
+               } else {
+                 print("The array was empty")
+                 throw DiscombobulationError.arrayWasEmpty
+               }
+             }
+             """,
+      expected: """
+                func discombobulate(_ values: [Int]) throws -> Int {
+
+                  // Comment 1
+
+                  /*Comment 2*/ guard let first = values.first else {
+                    print("The array was empty")
+                    throw DiscombobulationError.arrayWasEmpty
+                  }
+                  // Comment 3
+
+                  /// Doc comment
+                  guard first >= 0 else {
+                    print("Can't have negative energy")
+                    throw DiscombobulationError.negativeEnergy
+                  }
+                  // Comment 4
+                  var result = 0
+                  for value in values {
+                    result += invertedCombobulatoryFactor(of: value)
+                  }
+                  return result
+                }
+                """)
+    
+  }
+  
+  #if !os(macOS)
+  static let allTests = [
+    UseEarlyExitsTests.testSwitchStmts,
+    ]
+  #endif
+
+}