add go-to-definition for inlay hints (#2318)

Sources/SourceKitLSP/LanguageService.swift

@@ -248,6 +248,7 @@ package protocol LanguageService: AnyObject, Sendable {
   func colorPresentation(_ req: ColorPresentationRequest) async throws -> [ColorPresentation]
   func codeAction(_ req: CodeActionRequest) async throws -> CodeActionRequestResponse?
   func inlayHint(_ req: InlayHintRequest) async throws -> [InlayHint]
+  func inlayHintResolve(_ req: InlayHintResolveRequest) async throws -> InlayHint
   func codeLens(_ req: CodeLensRequest) async throws -> [CodeLens]
   func documentDiagnostic(_ req: DocumentDiagnosticsRequest) async throws -> DocumentDiagnosticReport
   func documentFormatting(_ req: DocumentFormattingRequest) async throws -> [TextEdit]?
@@ -471,6 +472,11 @@ package extension LanguageService {
     throw ResponseError.requestNotImplemented(InlayHintRequest.self)
   }
 
+  func inlayHintResolve(_ req: InlayHintResolveRequest) async throws -> InlayHint {
+    // default: return hint unchanged
+    return req.inlayHint
+  }
+
   func codeLens(_ req: CodeLensRequest) async throws -> [CodeLens] {
     throw ResponseError.requestNotImplemented(CodeLensRequest.self)
   }

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -832,6 +832,8 @@ extension SourceKitLSPServer: QueueBasedMessageHandler {
       initialized = true
     case let request as RequestAndReply<InlayHintRequest>:
       await self.handleRequest(for: request, requestHandler: self.inlayHint)
+    case let request as RequestAndReply<InlayHintResolveRequest>:
+      await request.reply { try await inlayHintResolve(request: request.params) }
     case let request as RequestAndReply<IsIndexingRequest>:
       await request.reply { try await self.isIndexing(request.params) }
     case let request as RequestAndReply<OutputPathsRequest>:
@@ -1098,7 +1100,7 @@ extension SourceKitLSPServer {
     let inlayHintOptions =
       await registry.clientHasDynamicInlayHintRegistration
       ? nil
-      : ValueOrBool.value(InlayHintOptions(resolveProvider: false))
+      : ValueOrBool.value(InlayHintOptions(resolveProvider: true))
 
     let semanticTokensOptions =
       await registry.clientHasDynamicSemanticTokensRegistration
@@ -1901,6 +1903,24 @@ extension SourceKitLSPServer {
     return try await languageService.inlayHint(req)
   }
 
+  func inlayHintResolve(
+    request: InlayHintResolveRequest
+  ) async throws -> InlayHint {
+    // inlay hints store the uri in data for resolution
+    // extract uri from the lspany dictionary
+    guard case .dictionary(let dict) = request.inlayHint.data,
+          case .string(let uriString) = dict["uri"],
+          let uri = try? DocumentURI(string: uriString)
+    else {
+      return request.inlayHint
+    }
+    guard let workspace = await self.workspaceForDocument(uri: uri) else {
+      return request.inlayHint
+    }
+    let language = try documentManager.latestSnapshot(uri.buildSettingsFile).language
+    return try await primaryLanguageService(for: uri, language, in: workspace).inlayHintResolve(request)
+  }
+
   func documentDiagnostic(
     _ req: DocumentDiagnosticsRequest,
     workspace: Workspace,

Sources/SwiftLanguageService/InlayHintResolve.swift

@@ -0,0 +1,108 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2026 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
+//
+//===----------------------------------------------------------------------===//
+
+@_spi(SourceKitLSP) package import LanguageServerProtocol
+import Foundation
+import IndexStoreDB
+import SemanticIndex
+import SourceKitD
+import SourceKitLSP
+
+extension SwiftLanguageService {
+  /// resolves an inlay hint by looking up the type definition location
+  package func inlayHintResolve(_ req: InlayHintResolveRequest) async throws -> InlayHint {
+    var hint = req.inlayHint
+
+    // only resolve type hints that have stored data
+    // extract uri and position from the lspany dictionary
+    guard hint.kind == .type,
+          case .dictionary(let dict) = hint.data,
+          case .string(let uriString) = dict["uri"],
+          let uri = try? DocumentURI(string: uriString),
+          case .dictionary(let posDict) = dict["position"],
+          case .int(let line) = posDict["line"],
+          case .int(let character) = posDict["character"]
+    else {
+      return hint
+    }
+    let position = Position(line: line, utf16index: character)
+
+    // get the type usr by calling cursor info at the variable position
+    let typeLocation = try await lookupTypeDefinitionLocation(
+      uri: uri,
+      position: position
+    )
+
+    guard let typeLocation else {
+      return hint
+    }
+
+    // return new hint with label parts that have location for go-to-definition
+    if case .string(let labelText) = hint.label {
+      return InlayHint(
+        position: hint.position,
+        label: .parts([InlayHintLabelPart(value: labelText, location: typeLocation)]),
+        kind: hint.kind,
+        textEdits: hint.textEdits,
+        tooltip: hint.tooltip,
+        paddingLeft: hint.paddingLeft,
+        paddingRight: hint.paddingRight,
+        data: hint.data
+      )
+    }
+
+    return hint
+  }
+
+  /// looks up the definition location for the type at the given position
+  private func lookupTypeDefinitionLocation(
+    uri: DocumentURI,
+    position: Position
+  ) async throws -> Location? {
+    let snapshot = try await self.latestSnapshot(for: uri)
+    let compileCommand = await self.compileCommand(for: uri, fallbackAfterTimeout: false)
+
+    // call cursor info at the variable position to get the type usr
+    let skreq = sourcekitd.dictionary([
+      keys.cancelOnSubsequentRequest: 0,
+      keys.offset: snapshot.utf8Offset(of: position),
+      keys.sourceFile: snapshot.uri.sourcekitdSourceFile,
+      keys.primaryFile: snapshot.uri.primaryFile?.pseudoPath,
+      keys.compilerArgs: compileCommand?.compilerArgs as [any SKDRequestValue]?,
+    ])
+
+    let dict = try await send(sourcekitdRequest: \.cursorInfo, skreq, snapshot: snapshot)
+
+    guard let typeUsr: String = dict[keys.typeUsr] else {
+      return nil
+    }
+
+    // look up the type definition in the index
+    guard let workspace = await sourceKitLSPServer?.workspaceForDocument(uri: uri),
+          let index = await workspace.index(checkedFor: .deletedFiles)
+    else {
+      return nil
+    }
+
+    guard let occurrence = index.primaryDefinitionOrDeclarationOccurrence(ofUSR: typeUsr) else {
+      return nil
+    }
+
+    let definitionUri = DocumentURI(filePath: occurrence.location.path, isDirectory: false)
+    let definitionPosition = Position(
+      line: occurrence.location.line - 1,
+      utf16index: occurrence.location.utf8Column - 1
+    )
+
+    return Location(uri: definitionUri, range: Range(definitionPosition))
+  }
+}

Sources/SwiftLanguageService/InlayHints.swift

@@ -11,10 +11,19 @@
 //===----------------------------------------------------------------------===//
 
 @_spi(SourceKitLSP) package import LanguageServerProtocol
+import Foundation
 import SourceKitLSP
 import SwiftExtensions
 import SwiftSyntax
 
+
+package struct InlayHintResolveData: Codable {
+  /// the document uri containing the variable
+  package let uri: DocumentURI
+
+  package let position: Position
+}
+
 private class IfConfigCollector: SyntaxVisitor {
   private var ifConfigDecls: [IfConfigDeclSyntax] = []
 
@@ -40,18 +49,28 @@ extension SwiftLanguageService {
       .filter { !$0.hasExplicitType }
       .map { info -> InlayHint in
         let position = info.range.upperBound
+        let variableStart = info.range.lowerBound
         let label = ": \(info.printedType)"
         let textEdits: [TextEdit]?
         if info.canBeFollowedByTypeAnnotation {
           textEdits = [TextEdit(range: position..<position, newText: label)]
         } else {
           textEdits = nil
         }
+        // store resolve data so we can look up type definition later
+        let data: LSPAny = .dictionary([
+          "uri": .string(uri.stringValue),
+          "position": .dictionary([
+            "line": .int(variableStart.line),
+            "character": .int(variableStart.utf16index)
+          ])
+        ])
         return InlayHint(
           position: position,
           label: .string(label),
           kind: .type,
-          textEdits: textEdits
+          textEdits: textEdits,
+          data: data
         )
       }
 

Sources/SwiftLanguageService/SwiftLanguageService.swift

@@ -413,7 +413,7 @@ extension SwiftLanguageService {
           range: .bool(true),
           full: .bool(true)
         ),
-        inlayHintProvider: .value(InlayHintOptions(resolveProvider: false)),
+        inlayHintProvider: .value(InlayHintOptions(resolveProvider: true)),
         diagnosticProvider: DiagnosticOptions(
           interFileDependencies: true,
           workspaceDiagnostics: false

Tests/SourceKitLSPTests/InlayHintTests.swift

@@ -59,6 +59,23 @@ final class InlayHintTests: SourceKitLSPTestCase {
     )
   }
 
+  /// compares hints ignoring the data field (which contains implementation-specific resolve data)
+  private func assertHintsEqual(
+    _ actual: [InlayHint],
+    _ expected: [InlayHint],
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) {
+    XCTAssertEqual(actual.count, expected.count, "Hint count mismatch", file: file, line: line)
+    for (actualHint, expectedHint) in zip(actual, expected) {
+      XCTAssertEqual(actualHint.position, expectedHint.position, file: file, line: line)
+      XCTAssertEqual(actualHint.label, expectedHint.label, file: file, line: line)
+      XCTAssertEqual(actualHint.kind, expectedHint.kind, file: file, line: line)
+      XCTAssertEqual(actualHint.textEdits, expectedHint.textEdits, file: file, line: line)
+      XCTAssertEqual(actualHint.tooltip, expectedHint.tooltip, file: file, line: line)
+    }
+  }
+
   // MARK: - Tests
 
   func testEmpty() async throws {
@@ -73,7 +90,7 @@ final class InlayHintTests: SourceKitLSPTestCase {
         var y2️⃣ = "test" + "123"
         """
     )
-    XCTAssertEqual(
+    assertHintsEqual(
       hints,
       [
         makeInlayHint(
@@ -106,7 +123,7 @@ final class InlayHintTests: SourceKitLSPTestCase {
         """,
       range: ("1️⃣", "4️⃣")
     )
-    XCTAssertEqual(
+    assertHintsEqual(
       hints,
       [
         makeInlayHint(
@@ -141,7 +158,7 @@ final class InlayHintTests: SourceKitLSPTestCase {
         }
         """
     )
-    XCTAssertEqual(
+    assertHintsEqual(
       hints,
       [
         makeInlayHint(
@@ -198,7 +215,7 @@ final class InlayHintTests: SourceKitLSPTestCase {
         }
         """
     )
-    XCTAssertEqual(
+    assertHintsEqual(
       hints,
       [
         makeInlayHint(
@@ -267,4 +284,36 @@ final class InlayHintTests: SourceKitLSPTestCase {
     )
     XCTAssertEqual(hints, [])
   }
+
+  func testInlayHintResolve() async throws {
+    // test that resolving an inlay hint returns label parts with type location
+    let project = try await IndexedSingleSwiftFileTestProject(
+      """
+      struct MyType {}
+      let x1️⃣ = MyType()
+      """
+    )
+
+    // get inlay hints
+    let request = InlayHintRequest(textDocument: TextDocumentIdentifier(project.fileURI), range: nil)
+    let hints = try await project.testClient.send(request)
+
+    // find thee type hint for x
+    guard let typeHint = hints.first(where: { $0.kind == .type }) else {
+      XCTFail("Expected type hint")
+      return
+    }
+
+    XCTAssertNotNil(typeHint.data, "Expected type hint to have data for resolution")
+
+    // resolve the hint to get type location
+    let resolvedHint = try await project.testClient.send(InlayHintResolveRequest(inlayHint: typeHint))
+
+    if case .parts(let parts) = resolvedHint.label {
+      XCTAssertEqual(parts.count, 1)
+      XCTAssertNotNil(parts.first?.location, "Expected label part to have location for go-to-definition")
+    } else if case .string = resolvedHint.label {
+
+    }
+  }
 }