Implementation of NoBlockComments (swiftlang#70)

Author: atamez31

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

@@ -14,5 +14,116 @@ import SwiftSyntax
 ///
 /// - SeeAlso: https://google.github.io/swift#non-documentation-comments
 public final class NoBlockComments: SyntaxFormatRule {
+  public override func visit (_ token: TokenSyntax) -> Syntax {
+    var pieces = [TriviaPiece]()
+    var hasBlockComment = false
+    var validToken = token
 
+    // Ensures that the comments that appear inline with code have
+    // at least 2 spaces before the `//`.
+    if let nextToken = token.nextToken,
+      containsBlockCommentInline(trivia: nextToken.leadingTrivia) {
+      hasBlockComment = true
+      validToken = addSpacesBeforeComment(token)
+    }
+    
+    // Ensures that all block comments are replaced with line comment,
+    // unless the comment is between tokens on the same line.
+    for piece in token.leadingTrivia {
+      if case .blockComment(let text) = piece,
+        !commentIsBetweenCode(token) {
+        diagnose(.avoidBlockComment, on: token)
+        hasBlockComment = true
+        let lineCommentText = convertBlockCommentsToLineComments(text)
+        let lineComment = TriviaPiece.lineComment(lineCommentText)
+        pieces.append(lineComment)
+      }
+      else {
+        pieces.append(piece)
+      }
+    }
+    validToken =  validToken.withLeadingTrivia(Trivia(pieces: pieces))
+    return hasBlockComment ? validToken : token
+  }
+  
+  /// Returns a Boolean value indicating if the given trivia has a piece trivia
+  /// of block comment inline with code.
+  private func containsBlockCommentInline(trivia: Trivia) -> Bool {
+    // When the comment isn't inline with code, it doesn't need to
+    // to check that there are two spaces before the line comment.
+    if let firstPiece = trivia.first {
+      if case .newlines(_) = firstPiece {
+        return false
+      }
+    }
+    for piece in trivia {
+      if case .blockComment(_) = piece {
+        return true
+      }
+    }
+    return false
+  }
+  
+  /// Indicates if a block comment is between tokens on the same line.
+  /// If it does, it should only raise a lint error.
+  private func commentIsBetweenCode(_ token: TokenSyntax) -> Bool {
+    let hasCommentBetweenCode = token.leadingTrivia.isBetweenTokens
+    if hasCommentBetweenCode {
+      diagnose(.avoidBlockCommentBetweenCode, on: token)
+    }
+    return hasCommentBetweenCode
+  }
+  
+  /// Ensures there is always at least 2 spaces before the comment.
+  private func addSpacesBeforeComment(_ token: TokenSyntax) -> TokenSyntax {
+    let numSpaces = token.trailingTrivia.numberOfSpaces
+    if numSpaces < 2 {
+      let addSpaces = 2 - numSpaces
+      return token.withTrailingTrivia(token.trailingTrivia
+        .appending(.spaces(addSpaces)))
+    }
+    return token
+  }
+  
+  /// Receives the text of a Block comment and converts it to a Line Comment format text.
+  private func convertBlockCommentsToLineComments(_ text: String) -> String {
+    // Removes the '/*', '*/', the extra spaces and newlines from the comment.
+    let textTrim = text.dropFirst(2).dropLast(2)
+        .trimmingCharacters(in: .whitespacesAndNewlines)
+    
+    let splitComment = textTrim.split(separator: "\n", omittingEmptySubsequences: false)
+    var lineCommentText = [String]()
+    
+    for line in splitComment {
+      let startsComment = line.starts(with: " ") || line.count == 0 ? "//" : "// "
+      lineCommentText.append(startsComment + line)
+    }
+    return lineCommentText.joined(separator: "\n")
+  }
+}
+
+extension Diagnostic.Message {
+  static let avoidBlockComment = Diagnostic.Message(.warning, "Replace block comment with line comments.")
+  static let avoidBlockCommentBetweenCode = Diagnostic.Message(.warning, "Remove block comment inline with code")
+}
+
+extension Trivia {
+  /// Indicates if the trivia is between tokens, for example
+  /// if a leading trivia that contains a comment, doesn't starts
+  /// and finishes with a new line then the comment is between tokens.
+  var isBetweenTokens: Bool {
+    var beginsNewLine = false
+    var endsNewLine = false
+    
+    if let firstPiece = self.first,
+      let lastPiece = self.reversed().first {
+      if case .newlines(_) = firstPiece {
+        beginsNewLine = true
+      }
+      if case .newlines(_) = lastPiece {
+        endsNewLine = true
+      }
+    }
+    return !beginsNewLine && !endsNewLine
+  }
 }

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

@@ -0,0 +1,50 @@
+import SwiftSyntax
+import XCTest
+
+@testable import Rules
+
+public class NoBlockCommentsTests: DiagnosingTestCase {
+  public func testRemoveBlockComments() {
+    XCTAssertFormatting(
+      NoBlockComments.self,
+      input: """
+             /*
+             Lorem ipsum dolor sit amet, at nonumes adipisci sea, natum
+             offendit vis ex. Audiam legendos expetenda ei quo, nonumes
+
+                 msensibus eloquentiam ex vix.
+             */
+             let a = /*ff*/10  /*ff*/ + 10
+             var b = 0/*Block Comment inline with code*/
+
+             /*
+
+             Block Comment
+             */
+             let c = a + b
+             /* This is the end
+             of a file
+
+             */
+             """,
+      expected: """
+                // Lorem ipsum dolor sit amet, at nonumes adipisci sea, natum
+                // offendit vis ex. Audiam legendos expetenda ei quo, nonumes
+                //
+                //    msensibus eloquentiam ex vix.
+                let a =  /*ff*/10  /*ff*/ + 10
+                var b = 0  // Block Comment inline with code
+
+                // Block Comment
+                let c = a + b
+                // This is the end
+                // of a file
+                """)
+  }
+  
+  #if !os(macOS)
+  static let allTests = [
+    NoBlockCommentsTests.testRemoveBlockComments,
+    ]
+  #endif
+}