Support formatting of entire documents

Since swift-syntax no longer depends on the C++ parser library and thus swift-format also doesn’t, we can use swift-format to format an entire document.

Fixes swiftlang#576
rdar://96159694

Author: ahoppen

Package.swift

@@ -63,6 +63,7 @@ let package = Package(
           .product(name: "SwiftSyntax", package: "swift-syntax"),
           .product(name: "SwiftParser", package: "swift-syntax"),
           .product(name: "SwiftIDEUtils", package: "swift-syntax"),
+          .product(name: "SwiftFormat", package: "swift-format"),
         ],
         exclude: ["CMakeLists.txt"]),
 
@@ -254,13 +255,15 @@ if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
     .package(url: "https://github.com/apple/swift-tools-support-core.git", branch: "main"),
     .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.2.2"),
     .package(url: "https://github.com/apple/swift-syntax.git", branch: "main"),
+    .package(url: "https://github.com/apple/swift-format.git", branch: "main"),
   ]
 } else {
   package.dependencies += [
     .package(path: "../indexstore-db"),
     .package(name: "swift-package-manager", path: "../swiftpm"),
     .package(path: "../swift-tools-support-core"),
     .package(path: "../swift-argument-parser"),
-    .package(path: "../swift-syntax")
+    .package(path: "../swift-syntax"),
+    .package(path: "../swift-format"),
   ]
 }

README.md

@@ -46,7 +46,7 @@ SourceKit-LSP is still in early development, so you may run into rough edges wit
 | Workspace Symbols | ✅ | |
 | Rename | ❌ | |
 | Local Refactoring | ✅ | |
-| Formatting | ❌ | |
+| Formatting | ✅ | Whole file at once only. |
 | Folding | ✅ | |
 | Syntax Highlighting | ✅ | Both syntactic and semantic tokens |
 | Document Symbols | ✅ |  |

Sources/LanguageServerProtocol/Requests/FormattingRequests.swift

@@ -28,6 +28,11 @@ public struct DocumentFormattingRequest: TextDocumentRequest, Hashable {
 
   /// Options to customize the formatting.
   public var options: FormattingOptions
+
+  public init(textDocument: TextDocumentIdentifier, options: FormattingOptions) {
+    self.textDocument = textDocument
+    self.options = options
+  }
 }
 
 /// Request to format a specified range within a document.
@@ -106,4 +111,18 @@ public struct FormattingOptions: Codable, Hashable {
 
   /// Trim all newlines after the final newline at the end of the file.
   public var trimFinalNewlines: Bool?
+
+  public init(
+    tabSize: Int,
+    insertSpaces: Bool,
+    trimTrailingWhitespace: Bool? = nil,
+    insertFinalNewline: Bool? = nil,
+    trimFinalNewlines: Bool? = nil
+  ) {
+    self.tabSize = tabSize
+    self.insertSpaces = insertSpaces
+    self.trimTrailingWhitespace = trimTrailingWhitespace
+    self.insertFinalNewline = insertFinalNewline
+    self.trimFinalNewlines = trimFinalNewlines
+  }
 }

Sources/SourceKitLSP/Clang/ClangLanguageServer.swift

@@ -496,6 +496,10 @@ extension ClangLanguageServerShim {
     forwardRequestToClangdOnQueue(req)
   }
 
+  func documentFormatting(_ req: Request<DocumentFormattingRequest>) {
+    forwardRequestToClangdOnQueue(req)
+  }
+
   func colorPresentation(_ req: Request<ColorPresentationRequest>) {
     queue.async {
       if self.capabilities?.colorProvider?.isSupported == true {

Sources/SourceKitLSP/SourceKitServer.swift

@@ -195,6 +195,7 @@ public final class SourceKitServer: LanguageServer {
     registerToolchainTextDocumentRequest(SourceKitServer.documentSymbolHighlight, nil)
     registerToolchainTextDocumentRequest(SourceKitServer.foldingRange, nil)
     registerToolchainTextDocumentRequest(SourceKitServer.documentSymbol, nil)
+    registerToolchainTextDocumentRequest(SourceKitServer.documentFormatting, nil)
     registerToolchainTextDocumentRequest(SourceKitServer.documentColor, [])
     registerToolchainTextDocumentRequest(SourceKitServer.documentSemanticTokens, nil)
     registerToolchainTextDocumentRequest(SourceKitServer.documentSemanticTokensDelta, nil)
@@ -665,6 +666,7 @@ extension SourceKitServer {
         codeActionOptions: CodeActionOptions(codeActionKinds: nil),
         supportsCodeActions: true
       )),
+      documentFormattingProvider: .value(DocumentFormattingOptions(workDoneProgress: false)),
       colorProvider: .bool(true),
       foldingRangeProvider: .bool(!registry.clientHasDynamicFoldingRangeRegistration),
       declarationProvider: .bool(true),
@@ -1135,6 +1137,15 @@ extension SourceKitServer {
     languageService.documentSemanticTokensRange(req)
   }
 
+  func documentFormatting(
+    _ req: Request<DocumentFormattingRequest>,
+    workspace: Workspace,
+    languageService: ToolchainLanguageServer
+  ) {
+    languageService.documentFormatting(req)
+  }
+
+
   func colorPresentation(
     _ req: Request<ColorPresentationRequest>,
     workspace: Workspace,
@@ -1188,6 +1199,7 @@ extension SourceKitServer {
     languageService.executeCommand(request)
   }
 
+
   func codeAction(
     _ req: Request<CodeActionRequest>,
     workspace: Workspace,

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -19,6 +19,8 @@ import SKSupport
 import SourceKitD
 import SwiftSyntax
 import SwiftParser
+import SwiftFormat
+import SwiftFormatConfiguration
 
 #if os(Windows)
 import WinSDK
@@ -1461,6 +1463,72 @@ extension SwiftLanguageServer {
     // FIXME: cancellation
     _ = handle
   }
+
+  public func documentFormatting(_ req: Request<DocumentFormattingRequest>) {
+    self.queue.async {
+      do {
+        req.reply(try self.handleDocumentUpdate(req.params))
+      } catch let error as ResponseError {
+        req.reply(.failure(error))
+      } catch {
+        req.reply(.failure(ResponseError(code: .requestFailed, message: "Formatting failed: \(error.localizedDescription)")))
+      }
+    }
+  }
+
+  public func handleDocumentUpdate(_ req: DocumentFormattingRequest) throws -> [TextEdit]? {
+    guard let snapshot = documentManager.latestSnapshot(req.textDocument.uri) else {
+      return nil
+    }
+
+    var formatConfiguration: Configuration
+    if let fileURL = req.textDocument.uri.fileURL,
+        let configURL = Configuration.url(forConfigurationFileApplyingTo: fileURL),
+        let configuration = try? Configuration(contentsOf: configURL) {
+      formatConfiguration = configuration
+      // If we find a .swift-format file, we ignore the options passed to us by the editor.
+      // Most likely, the editor inferred them from the current document and thus the options
+      // passed by the editor are most likely less correct than those in .swift-format.
+    } else {
+      formatConfiguration = Configuration()
+      formatConfiguration.tabWidth = req.options.tabSize
+      formatConfiguration.indentation = req.options.insertSpaces ? .spaces(req.options.tabSize) : .tabs(1)
+    }
+
+    // Unsupported options
+    if req.options.trimTrailingWhitespace == false {
+      throw ResponseError(code: .requestFailed, message: "swift-format does not support keeping trailing whitespace; set format option to trim trailing trivia to run the formatter")
+    }
+    if req.options.insertFinalNewline == false {
+      throw ResponseError(code: .requestFailed, message: "swift-format always inserts a final newline to the file; set option to insert a final newline to run the formatter")
+    }
+    if req.options.trimFinalNewlines == false {
+      throw ResponseError(code: .requestFailed, message: "swift-format always trims final newlines; set option to trim final newlines to run the formatter")
+    }
+
+    var outputBuffer = ""
+    let formatter = SwiftFormatter(configuration: formatConfiguration)
+    try formatter.format(source: snapshot.text, assumingFileURL: req.textDocument.uri.fileURL, to: &outputBuffer)
+
+    if snapshot.text == outputBuffer {
+      // No changes to the document.
+      return []
+    }
+
+    // It would be nice if swift-format could tell us which edits it performed.
+    // We also can’t compute the changes using `CollectionDifference` because it
+    // returns offset in the collection that were modified, but we need UTF-16
+    // indicies and it would be pretty hard to translate between the two.
+    // Thus, just return an edit that replaces the entire document.
+    let documentEndPos: Position
+    if snapshot.lineTable.isEmpty {
+      documentEndPos = Position(line: 0, utf16index: 0)
+    } else {
+      documentEndPos = Position(line: snapshot.lineTable.count - 1, utf16index: snapshot.lineTable.last!.utf16.count)
+    }
+
+    return [TextEdit(range: Position(line: 0, utf16index: 0)..<documentEndPos, newText: outputBuffer)]
+  }
 }
 
 extension SwiftLanguageServer: SKDNotificationHandler {

Sources/SourceKitLSP/ToolchainLanguageServer.swift

@@ -101,6 +101,7 @@ public protocol ToolchainLanguageServer: AnyObject {
   // MARK: - Other
 
   func executeCommand(_ req: Request<ExecuteCommandRequest>)
+  func documentFormatting(_ req: Request<DocumentFormattingRequest>)
 
   /// Crash the language server. Should be used for crash recovery testing only.
   func _crash()

Tests/SourceKitLSPTests/FormattingTests.swift

@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import LanguageServerProtocol
+import LSPLogging
+import LSPTestSupport
+import SKTestSupport
+import SourceKitLSP
+import XCTest
+
+final class FormattingTests: XCTestCase {
+
+  /// Connection and lifetime management for the service.
+  var connection: TestSourceKitServer! = nil
+
+  /// The primary interface to make requests to the SourceKitServer.
+  var sk: TestClient! = nil
+
+  var documentManager: DocumentManager! {
+    connection.server!._documentManager
+  }
+
+  override func setUp() {
+    connection = TestSourceKitServer()
+    sk = connection.client
+    _ = try! sk.sendSync(
+      InitializeRequest(
+        processId: nil,
+        rootPath: nil,
+        rootURI: nil,
+        initializationOptions: nil,
+        capabilities: ClientCapabilities(
+          workspace: nil,
+          textDocument: TextDocumentClientCapabilities(
+            codeAction: .init(
+              codeActionLiteralSupport: .init(
+                codeActionKind: .init(valueSet: [.quickFix])
+              )
+            ),
+            publishDiagnostics: .init(codeDescriptionSupport: true)
+          )
+        ),
+        trace: .off,
+        workspaceFolders: nil
+      )
+    )
+  }
+
+  override func tearDown() {
+    sk = nil
+    connection = nil
+  }
+
+  func testFormatting() throws {
+    let url = URL(fileURLWithPath: "/\(UUID())/a.swift")
+    let uri = DocumentURI(url)
+
+    sk.send(DidOpenTextDocumentNotification(textDocument: TextDocumentItem(
+      uri: uri,
+      language: .swift,
+      version: 1,
+      text: """
+      struct S {
+      var foo: Int
+      }
+      """)))
+
+    let resp = try sk.sendSync(
+      DocumentFormattingRequest(
+        textDocument: TextDocumentIdentifier(url),
+        options: FormattingOptions(
+          tabSize: 2,
+          insertSpaces: true
+        )
+      )
+    )
+
+    let edits = try XCTUnwrap(resp)
+    XCTAssertEqual(edits.count, 1)
+    let edit = try XCTUnwrap(edits.first)
+    XCTAssertEqual(edit.range, Position(line: 0, utf16index: 0)..<Position(line: 2, utf16index: 1))
+    XCTAssertEqual(edit.newText, """
+    struct S {
+      var foo: Int
+    }
+
+    """)
+  }
+
+  func testFormattingNoEdits() throws {
+    let url = URL(fileURLWithPath: "/\(UUID())/a.swift")
+    let uri = DocumentURI(url)
+
+    sk.send(DidOpenTextDocumentNotification(textDocument: TextDocumentItem(
+      uri: uri,
+      language: .swift,
+      version: 1,
+      text: """
+      struct S {
+        var foo: Int
+      }
+
+      """)))
+
+    let resp = try sk.sendSync(
+      DocumentFormattingRequest(
+        textDocument: TextDocumentIdentifier(url),
+        options: FormattingOptions(
+          tabSize: 2,
+          insertSpaces: true
+        )
+      )
+    )
+
+    let edits = try XCTUnwrap(resp)
+    XCTAssertEqual(edits.count, 0)
+  }
+}