Implement maximum blank lines (swiftlang#80)

Author: atamez31

tools/swift-format/Sources/Rules/MaximumBlankLines.swift

@@ -16,5 +16,72 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#vertical-whitespace
 public final class MaximumBlankLines: SyntaxFormatRule {
+  public override func visit(_ token: TokenSyntax) -> Syntax {
+    guard let parentToken = token.parent else {
+      return token.withLeadingTrivia(removeExtraBlankLines(token).newTrivia)
+    }
 
+    guard let grandparentTok = parentToken.parent else {
+      return token.withLeadingTrivia(removeExtraBlankLines(token).newTrivia)
+    }
+
+    // Tokens who appeared in a member type are handle by
+    // BlankLineBetweenMembers rule.
+    if grandparentTok is MemberDeclListItemSyntax {
+      return token
+    }
+    else {
+      let (correctTrivia, hasValidAmountOfBlankLines) = removeExtraBlankLines(token)
+      return hasValidAmountOfBlankLines ? token : token.withLeadingTrivia(correctTrivia)
+    }
+  }
+
+  /// Indicates if the given trivia contains an invalid amount of
+  /// consecutively blank lines. If it does it returns a clean trivia
+  /// with the correct amount of blank lines.
+  func removeExtraBlankLines(_ token: TokenSyntax) -> (
+    newTrivia: Trivia,
+    hasValidAmountOfBlankLines: Bool
+  ) {
+    let maxBlankLines = context.configuration.maximumBlankLines
+    var pieces = [TriviaPiece]()
+    let isTheFirstOne = token == token.root.firstToken
+    let tokenTrivia = token.leadingTrivia
+    var startsIn = 0
+    var hasValidAmountOfBlankLines = true
+    let triviaWithoutTrailingSpaces = tokenTrivia.withoutTrailingSpaces()
+
+    // Ensures the beginning of file doesn't have an invalid amount of blank line.
+    // The first triviapiece of a file is a special case, where each newline is
+    // a blank line.
+    if isTheFirstOne, let firstPiece = triviaWithoutTrailingSpaces.first,
+       case .newlines(let num) = firstPiece, num > maxBlankLines {
+      pieces.append(.newlines(maxBlankLines))
+      diagnose(.removeMaxBlankLines(count: num - maxBlankLines), on: token)
+      startsIn = 1
+      hasValidAmountOfBlankLines = false
+    }
+
+    // Iterates through the token trivia, verifying that the number on blank
+    // lines in the file do not exceed the maximumBlankLines.
+    for index in startsIn..<triviaWithoutTrailingSpaces.count {
+      if case .newlines(let num) = triviaWithoutTrailingSpaces[index],
+         num - 1 > maxBlankLines {
+        pieces.append(.newlines(maxBlankLines + 1))
+        diagnose(.removeMaxBlankLines(count: num - maxBlankLines), on: token)
+        hasValidAmountOfBlankLines = false
+      }
+      else {
+        pieces.append(triviaWithoutTrailingSpaces[index])
+      }
+    }
+    return (Trivia(pieces: pieces), hasValidAmountOfBlankLines)
+  }
+}
+
+extension Diagnostic.Message {
+  static func removeMaxBlankLines(count: Int) -> Diagnostic.Message {
+    let ending = count == 1 ? "" : "s"
+    return Diagnostic.Message(.warning, "remove \(count) blank line\(ending)")
+  }
 }

tools/swift-format/Sources/Rules/Trivia+Convenience.swift

@@ -21,6 +21,24 @@ extension Trivia {
     })
   }
 
+  /// Returns this set of trivia without any trailing whitespace characters.
+  func withoutTrailingSpaces() -> Trivia {
+    var pieces = [TriviaPiece]()
+    guard var prev = first else { return self }
+    for piece in dropFirst() {
+      switch (prev, piece) {
+      case (.spaces(_), .newlines(_)),
+           (.tabs(_), .newlines(_)):
+        prev = piece
+      default:
+        pieces.append(prev)
+        prev = piece
+      }
+    }
+    pieces.append(prev)
+    return Trivia(pieces: pieces).condensed()
+  }
+
   /// Returns this set of trivia, without any newlines.
   func withoutNewlines() -> Trivia {
     return Trivia(pieces: filter {

tools/swift-format/Tests/SwiftFormatTests/MaximumBlankLinesTests.swift

@@ -0,0 +1,142 @@
+import Foundation
+import XCTest
+import SwiftSyntax
+
+@testable import Rules
+
+public class MaximumBlankLinesTests: DiagnosingTestCase {
+  public func testInvalidMaximumBlankLines() {
+    XCTAssertFormatting(
+      MaximumBlankLines.self,
+      input: """
+
+
+             /// Doc Comment
+
+             import Foundation
+             let a = 1
+             let b = 2
+                   
+                    
+                  
+             // Multiline
+                   
+
+             // comment for b
+
+
+             var b = 12
+
+             // eof
+
+
+             """,
+      expected: """
+
+                /// Doc Comment
+
+                import Foundation
+                let a = 1
+                let b = 2
+
+                // Multiline
+
+                // comment for b
+
+                var b = 12
+                
+                // eof
+
+
+                """)
+  }
+  
+  public func testInvalidWithMemberTypesMaximumBlankLines() {
+    XCTAssertFormatting(
+      MaximumBlankLines.self,
+      input: """
+
+             struct foo {
+               let a = 1
+
+
+               let b = 2
+               var isTest: Bool {
+
+
+
+                 return true
+
+
+               }
+
+
+
+             }
+
+
+
+             struct test {}
+
+
+             """,
+      expected: """
+
+                struct foo {
+                  let a = 1
+
+
+                  let b = 2
+                  var isTest: Bool {
+
+                    return true
+
+                  }
+
+                }
+
+                struct test {}
+                
+
+                """)
+  }
+  
+  public func testIgnoreMultilineStrings() {
+    XCTAssertFormatting(
+      MaximumBlankLines.self,
+      input: """
+             // Blanklines in multiline string
+             // should be ignored.
+             let a = 1
+
+             
+             let strMulti = \"""
+                            This is a multiline
+                            
+                            
+                            string
+                            \"""
+             """,
+      expected: """
+                // Blanklines in multiline string
+                // should be ignored.
+                let a = 1
+
+                let strMulti = \"""
+                               This is a multiline
+                               
+                               
+                               string
+                               \"""
+                """)
+  }
+  
+  #if !os(macOS)
+  static let allTests = [
+    MaximumBlankLinesTests.testInvalidBlankMaximumBlankLines,
+    MaximumBlankLinesTests.testInvalidWithMemberTypesMaximumBlankLines,
+    MaximumBlankLinesTests.testIgnoreMultilineStrings,
+    
+    ]
+  #endif
+}