Merge pull request swiftlang#238 from benlangmuir/notes-and-multiples

[fixit] Add support for fixits that come from notes, and multi-edit fixes

Author: benlangmuir

Sources/LSPLogging/Logging.swift

@@ -37,6 +37,16 @@ public func logAsync(level: LogLevel = .default, messageProducer: @escaping (_ c
   Logger.shared.logAsync(level: level, messageProducer: messageProducer)
 }
 
+/// Log an error and trigger an assertion failure (if compiled with assertions).
+///
+/// If `level >= Logger.shared.currentLevel`, it will be emitted. However, the converse is not necessarily true: on platforms that provide `os_log`, the message may be emitted by `os_log` according to its own rules about log level.
+///
+/// - parameter message: The message to print.
+public func logAssertionFailure(_ message: String, file: StaticString = #file, line: UInt = #line) {
+  Logger.shared.log(message, level: .error)
+  assertionFailure(message, file: file, line: line)
+}
+
 /// Like `try?`, but logs the error on failure.
 public func orLog<R>(
   _ prefix: String = "",

Sources/LanguageServerProtocol/SupportTypes/Diagnostic.swift

@@ -77,9 +77,14 @@ public struct DiagnosticRelatedInformation: Codable, Hashable {
 
   public var message: String
 
-  public init(location: Location, message: String) {
+  /// All the code actions that address the parent diagnostic via this note.
+  /// **LSP Extension from clangd**.
+  public var codeActions: [CodeAction]?
+
+  public init(location: Location, message: String, codeActions: [CodeAction]?) {
     self.location = location
     self.message = message
+    self.codeActions = codeActions
   }
 }
 

Sources/SourceKit/sourcekitd/Diagnostic.swift

@@ -16,32 +16,56 @@ import SKSupport
 import sourcekitd
 
 extension CodeAction {
-  init?(fixit: SKResponseDictionary, in snapshot: DocumentSnapshot) {
-    let keys = fixit.sourcekitd.keys
 
-    guard let utf8Offset: Int = fixit[keys.offset],
-          let length: Int = fixit[keys.length],
-          let replacement: String = fixit[keys.sourcetext],
-          let position = snapshot.positionOf(utf8Offset: utf8Offset),
-          let endPosition = snapshot.positionOf(utf8Offset: utf8Offset + length),
-          let startIndex = snapshot.indexOf(utf8Offset: utf8Offset),
-          let endIndex = snapshot.indexOf(utf8Offset: utf8Offset + length),
-          length > 0 || !replacement.isEmpty
-    else {
+  /// Creates a CodeAction from a list for sourcekit fixits.
+  ///
+  /// If this is from a note, the note's description should be passed as `fromNote`.
+  init?(fixits: SKResponseArray, in snapshot: DocumentSnapshot, fromNote: String?) {
+    var edits: [TextEdit] = []
+    let editsMapped = fixits.forEach { (_, skfixit) -> Bool in
+      if let edit = TextEdit(fixit: skfixit, in: snapshot) {
+        edits.append(edit)
+        return true
+      }
+      return false
+    }
+
+    if !editsMapped {
+      log("failed to construct TextEdits from response \(fixits)", level: .warning)
       return nil
     }
 
-    let range = position..<endPosition
-    let original = String(snapshot.text[startIndex..<endIndex])
-    let title = Self.fixitTitle(replace: original, with: replacement)
-    let workspaceEdit = WorkspaceEdit(
-      changes: [snapshot.document.uri:[TextEdit(range: range, newText: replacement)]])
+    if edits.isEmpty {
+      return nil
+    }
+
+    let title: String
+    if let fromNote = fromNote {
+      title = fromNote
+    } else {
+      guard let startIndex = snapshot.index(of: edits[0].range.lowerBound),
+            let endIndex = snapshot.index(of: edits[0].range.upperBound),
+            startIndex <= endIndex,
+            snapshot.text.indices.contains(startIndex),
+            endIndex <= snapshot.text.endIndex
+      else {
+        logAssertionFailure("position mapped, but indices failed for edit range \(edits[0])")
+        return nil
+      }
+      let oldText = String(snapshot.text[startIndex..<endIndex])
+      let description = Self.fixitTitle(replace: oldText, with: edits[0].newText)
+      if edits.count == 1 {
+        title = description
+      } else {
+        title = description + "..."
+      }
+    }
 
     self.init(
       title: title,
       kind: .quickFix,
       diagnostics: nil,
-      edit: workspaceEdit)
+      edit: WorkspaceEdit(changes: [snapshot.document.uri:edits]))
   }
 
   /// Describe a fixit's edit briefly.
@@ -61,6 +85,25 @@ extension CodeAction {
   }
 }
 
+extension TextEdit {
+
+  /// Creates a TextEdit from a sourcekitd fixit response dictionary.
+  init?(fixit: SKResponseDictionary, in snapshot: DocumentSnapshot) {
+    let keys = fixit.sourcekitd.keys
+    if let utf8Offset: Int = fixit[keys.offset],
+       let length: Int = fixit[keys.length],
+       let replacement: String = fixit[keys.sourcetext],
+       let position = snapshot.positionOf(utf8Offset: utf8Offset),
+       let endPosition = snapshot.positionOf(utf8Offset: utf8Offset + length),
+       length > 0 || !replacement.isEmpty
+    {
+      self.init(range: position..<endPosition, newText: replacement)
+    } else {
+      return nil
+    }
+  }
+}
+
 extension Diagnostic {
 
   /// Creates a diagnostic from a sourcekitd response dictionary.
@@ -98,26 +141,18 @@ extension Diagnostic {
       }
     }
 
-    var fixits: [CodeAction]? = nil
-    if let skfixits: SKResponseArray = diag[keys.fixits] {
-      fixits = []
-      skfixits.forEach { (_, skfixit) -> Bool in
-        if let codeAction = CodeAction(fixit: skfixit, in: snapshot) {
-          fixits?.append(codeAction)
-        }
-        return true
-      }
+    var actions: [CodeAction]? = nil
+    if let skfixits: SKResponseArray = diag[keys.fixits],
+       let action = CodeAction(fixits: skfixits, in: snapshot, fromNote: nil) {
+      actions = [action]
     }
 
     var notes: [DiagnosticRelatedInformation]? = nil
     if let sknotes: SKResponseArray = diag[keys.diagnostics] {
       notes = []
       sknotes.forEach { (_, sknote) -> Bool in
-        guard let note = Diagnostic(sknote, in: snapshot) else { return true }
-        notes?.append(DiagnosticRelatedInformation(
-          location: Location(uri: snapshot.document.uri, range: note.range),
-          message: note.message
-        ))
+        guard let note = DiagnosticRelatedInformation(sknote, in: snapshot) else { return true }
+        notes?.append(note)
         return true
       }
     }
@@ -129,7 +164,42 @@ extension Diagnostic {
       source: "sourcekitd",
       message: message,
       relatedInformation: notes,
-      codeActions: fixits)
+      codeActions: actions)
+  }
+}
+
+extension DiagnosticRelatedInformation {
+
+  /// Creates related information from a sourcekitd note response dictionary.
+  init?(_ diag: SKResponseDictionary, in snapshot: DocumentSnapshot) {
+    let keys = diag.sourcekitd.keys
+
+    var position: Position? = nil
+    if let line: Int = diag[keys.line],
+       let utf8Column: Int = diag[keys.column],
+       line > 0, utf8Column > 0
+    {
+      position = snapshot.positionOf(zeroBasedLine: line - 1, utf8Column: utf8Column - 1)
+    } else if let utf8Offset: Int = diag[keys.offset] {
+      position = snapshot.positionOf(utf8Offset: utf8Offset)
+    }
+
+    if position == nil {
+      return nil
+    }
+
+    guard let message: String = diag[keys.description] else { return nil }
+
+    var actions: [CodeAction]? = nil
+    if let skfixits: SKResponseArray = diag[keys.fixits],
+       let action = CodeAction(fixits: skfixits, in: snapshot, fromNote: message) {
+      actions = [action]
+    }
+
+    self.init(
+      location: Location(uri: snapshot.document.uri, range: Range(position!)),
+      message: message,
+      codeActions: actions)
   }
 }
 

Sources/SourceKit/sourcekitd/SwiftLanguageServer.swift

@@ -1087,7 +1087,11 @@ extension SwiftLanguageServer {
     let codeActions = cachedDiags.flatMap { (cachedDiag) -> [CodeAction] in
       let diag = cachedDiag.diagnostic
 
-      guard let codeActions = diag.codeActions else {
+      let codeActions: [CodeAction] =
+        (diag.codeActions ?? []) +
+        (diag.relatedInformation?.flatMap{ $0.codeActions ?? [] } ?? [])
+
+      if codeActions.isEmpty {
         // The diagnostic doesn't have fix-its. Don't return anything.
         return []
       }
@@ -1115,6 +1119,13 @@ extension SwiftLanguageServer {
         var codeAction = $0
         var diagnosticWithoutCodeActions = diag
         diagnosticWithoutCodeActions.codeActions = nil
+        if let related = diagnosticWithoutCodeActions.relatedInformation {
+          diagnosticWithoutCodeActions.relatedInformation = related.map {
+            var withoutCodeActions = $0
+            withoutCodeActions.codeActions = nil
+            return withoutCodeActions
+          }
+        }
         codeAction.diagnostics = [diagnosticWithoutCodeActions]
         return codeAction
       })