Added a formatter for the diagnostics

Author: flashspys

Sources/swift-parser-test/DiagnosticsFormatter.swift

@@ -0,0 +1,131 @@
+//
+//  File.swift
+//  
+//
+//  Created by Felix Wehnert on 02.10.22.
+//
+
+import Foundation
+import SwiftParser
+import SwiftSyntax
+import SwiftDiagnostics
+
+
+// To put `Diagnostic`s into a set they must conform to hashable.
+// Two `Diagnostic` instances are the same, if they contain the same diagnosticID at the same node.
+extension Diagnostic: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(self.node)
+  }
+  
+  public static func ==(lhs: Diagnostic, rhs: Diagnostic) -> Bool {
+    return lhs.node == rhs.node && lhs.diagnosticID == rhs.diagnosticID
+  }
+}
+
+struct DiagnosticsFormatter {
+  
+  /**
+   A wrapper struct for a source line and its diagnostics
+   */
+  private struct SourceLine {
+    var diagnostics = Set<Diagnostic>()
+    var sourceString: String
+  }
+  
+  /**
+   Number of lines which should be printed before and after the diagnostic message
+   */
+  static let contextSize = 2
+  
+  /**
+   Print given diagnostics for a given syntax tree on the command line
+   */
+  static func printDiagnostics(tree: SourceFileSyntax, diags: [Diagnostic]) {
+    
+    let slc = SourceLocationConverter(file: "", tree: tree)
+    
+    // First, we need to put each line and its diagnostics together
+    var sourceLines = [SourceLine]()
+    
+    for sourceLine in tree.description.split(separator: "\n", omittingEmptySubsequences: false) {
+      
+      let diagsForLine = diags.filter { diag in
+        let line = diag.location(converter: slc).line
+        if line == (sourceLines.count + 1) {
+          return true
+        }
+        return false
+      }
+      
+      sourceLines.append(SourceLine(diagnostics: .init(diagsForLine), sourceString: String(sourceLine)))
+    }
+    
+    // Only lines with diagnostic messages should be printed, but including some context
+    let rangesToPrint = sourceLines.enumerated().compactMap { (index, sourceLine) -> Range<Int>? in
+      if sourceLine.diagnostics.isEmpty == false {
+        return Range<Int>(uncheckedBounds: (lower: index - Self.contextSize, upper: index + Self.contextSize))
+      }
+      return nil
+    }
+    
+    /// Keep track if a line missing char should be printed
+    var printLineMissingChar = false
+    /// Keep track if the first block of source lines were already printed
+    var isFirstLinePrinted = false
+    
+    for (lineNumber, line) in sourceLines.enumerated() {
+      guard rangesToPrint.contains(where: { range in
+        range.contains(lineNumber)
+      }) else {
+        printLineMissingChar = true
+        continue
+      }
+      
+      // line numbers should be right aligned
+      let numberOfDigits = Int(floor(log10(Float(abs(sourceLines.count))))) + 1
+      let lineNumberString = String(lineNumber + 1)
+      let leadingSpaces = Array(repeating: " ", count: numberOfDigits - lineNumberString.count).joined(separator: "")
+      let linePrefix = "\(leadingSpaces)\(lineNumberString) │ "
+      
+      // If necessary, print a line that indicates that there was lines skipped in the source code
+      if printLineMissingChar && isFirstLinePrinted {
+        let lineMissingInfoLine = Array(repeating: " ", count: numberOfDigits).joined(separator: "") + " ┆"
+        print("\(lineMissingInfoLine)")
+      }
+      printLineMissingChar = false
+      
+      // print the source line
+      print(linePrefix, line.sourceString, separator: "")
+      isFirstLinePrinted = true
+      
+      let columnsWithDiagnostics = Set(line.diagnostics.map { $0.location(converter: slc).column ?? 0 })
+      let diagsPerColumn = Dictionary(grouping: line.diagnostics) { diag in
+        diag.location(converter: slc).column ?? 0
+      }.sorted { lhs, rhs in
+        lhs.key > rhs.key
+      }
+      
+      for (column, diags) in diagsPerColumn {
+        
+        // compute the string that is shown before each message
+        var preMessage = Array(repeating: " ", count: numberOfDigits).joined(separator: "") + " ╷"
+        for c in 0..<column {
+          if columnsWithDiagnostics.contains(c) {
+            preMessage.append("│")
+          } else {
+            preMessage.append(" ")
+          }
+        }
+        
+        for diag in diags.dropLast(1) {
+          print(preMessage, "├─ ", diag.message, separator: "")
+        }
+        print(preMessage, "╰─ ", diags.last!.message, separator: "")
+        
+      }
+    }
+    print("")
+    
+  }
+}

Sources/swift-parser-test/swift-parser-test.swift

@@ -163,8 +163,10 @@ class PrintDiags: ParsableCommand {
         languageVersion: swiftVersion,
         enableBareSlashRegexLiteral: enableBareSlashRegex
       )
+      
       var diags = ParseDiagnosticsGenerator.diagnostics(for: tree)
-
+      DiagnosticsFormatter.printDiagnostics(tree: tree, diags: diags)
+      
       if foldSequences {
         diags += foldAllSequences(tree).1
       }