Fix module definition jumping in Swift interface files

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -1850,10 +1850,24 @@ extension SourceKitLSPServer {
     languageService: LanguageService
   ) async throws -> [Location] {
     // If this symbol is a module then generate a textual interface
-    if symbol.kind == .module, let name = symbol.name {
+    if symbol.kind == .module {
+      // For module symbols, prefer using systemModule information if available
+      let moduleName: String
+      let groupName: String?
+
+      if let systemModule = symbol.systemModule {
+        moduleName = systemModule.moduleName
+        groupName = systemModule.groupName
+      } else if let name = symbol.name {
+        moduleName = name
+        groupName = nil
+      } else {
+        return []
+      }
+
       let interfaceLocation = try await self.definitionInInterface(
-        moduleName: name,
-        groupName: nil,
+        moduleName: moduleName,
+        groupName: groupName,
         symbolUSR: nil,
         originatorUri: uri,
         languageService: languageService
@@ -2051,9 +2065,36 @@ extension SourceKitLSPServer {
     originatorUri: DocumentURI,
     languageService: LanguageService
   ) async throws -> Location {
+    // Check if we're already in the target interface with the same module/group/symbol
+    if case .generatedInterface(let interfaceData) = try? ReferenceDocumentURL(from: originatorUri),
+      interfaceData.moduleName == moduleName && interfaceData.groupName == groupName
+    {
+      // If we have a specific symbol USR, try to find its position in the current interface
+      if let symbolUSR = symbolUSR,
+        let swiftLanguageService = languageService as? SwiftLanguageService
+      {
+        do {
+          let position = try await swiftLanguageService.generatedInterfaceManager.position(
+            ofUsr: symbolUSR,
+            in: interfaceData
+          )
+          return Location(uri: originatorUri, range: Range(position))
+        } catch {
+          // If we can't find the symbol, just return the top of the current interface
+          return Location(uri: originatorUri, range: Range(Position(line: 0, utf16index: 0)))
+        }
+      } else {
+        // No specific symbol, just return the current interface location
+        return Location(uri: originatorUri, range: Range(Position(line: 0, utf16index: 0)))
+      }
+    }
+
+    // If the originator URI is already a generated interface, use its primary file for build settings
+    let documentForBuildSettings = originatorUri.buildSettingsFile
+
     guard
       let interfaceDetails = try await languageService.openGeneratedInterface(
-        document: originatorUri,
+        document: documentForBuildSettings,
         moduleName: moduleName,
         groupName: groupName,
         symbolUSR: symbolUSR

Sources/SourceKitLSP/Swift/GeneratedInterfaceDocumentURLData.swift

@@ -67,7 +67,7 @@ package struct GeneratedInterfaceDocumentURLData: Hashable, ReferenceURLData {
     self.moduleName = moduleName
     self.groupName = groupName
     self.sourcekitdDocumentName = sourcekitdDocumentName
-    self.buildSettingsFrom = primaryFile
+    self.buildSettingsFrom = primaryFile.buildSettingsFile
   }
 
   init(queryItems: [URLQueryItem]) throws {

Sources/SourceKitLSP/Swift/ReferenceDocumentURL.swift

@@ -170,8 +170,4 @@ extension DocumentURI {
 
 package struct ReferenceDocumentURLError: Error, CustomStringConvertible {
   package var description: String
-
-  init(description: String) {
-    self.description = description
-  }
 }

Tests/SourceKitLSPTests/SwiftInterfaceTests.swift

@@ -19,6 +19,10 @@ import SourceKitLSP
 import SwiftExtensions
 import XCTest
 
+private extension Language {
+  static let swiftinterface = Language(rawValue: "swiftinterface")
+}
+
 final class SwiftInterfaceTests: XCTestCase {
   func testSystemModuleInterface() async throws {
     let testClient = try await TestSourceKitLSPClient()
@@ -319,6 +323,64 @@ final class SwiftInterfaceTests: XCTestCase {
     )
     XCTAssertEqual(diagnostics.fullReport?.items, [])
   }
+
+  func testFoundationImportNavigation() async throws {
+    let testClient = try await TestSourceKitLSPClient(
+      capabilities: ClientCapabilities(experimental: [
+        GetReferenceDocumentRequest.method: .dictionary(["supported": .bool(true)])
+      ])
+    )
+    let uri = DocumentURI(for: .swiftinterface)
+
+    let positions = testClient.openDocument(
+      """
+      import 1️⃣Foundation
+      """,
+      uri: uri,
+      language: .swift
+    )
+
+    // Test navigation to Foundation module
+    let foundationDefinition = try await testClient.send(
+      DefinitionRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
+    )
+    let foundationLocation = try XCTUnwrap(foundationDefinition?.locations?.only)
+    // Verify it's a swiftinterface file (can be either file:// or sourcekit-lsp:// scheme)
+    XCTAssertTrue(foundationLocation.uri.scheme == "sourcekit-lsp")
+    XCTAssertTrue(foundationLocation.uri.pseudoPath.hasSuffix("Foundation.swiftinterface"))
+  }
+
+  func testFoundationSubmoduleNavigation() async throws {
+    let testClient = try await TestSourceKitLSPClient(
+      capabilities: ClientCapabilities(experimental: [
+        GetReferenceDocumentRequest.method: .dictionary(["supported": .bool(true)])
+      ])
+    )
+    let uri = DocumentURI(for: .swift)
+
+    let positions = testClient.openDocument(
+      """
+      import 1️⃣Foundation.2️⃣NSAffineTransform
+      """,
+      uri: uri
+    )
+
+    let foundationDefinition = try await testClient.send(
+      DefinitionRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
+    )
+    let foundationLocation = try XCTUnwrap(foundationDefinition?.locations?.only)
+    XCTAssertTrue(foundationLocation.uri.pseudoPath.contains("Foundation.swiftinterface"))
+    XCTAssertTrue(foundationLocation.uri.scheme == "sourcekit-lsp")
+
+    // Test navigation to NSAffineTransform
+    let transformDefinition = try await testClient.send(
+      DefinitionRequest(textDocument: TextDocumentIdentifier(uri), position: positions["2️⃣"])
+    )
+    let transformLocation = try XCTUnwrap(transformDefinition?.locations?.only)
+    // Verify we can identify this as a swiftinterface file
+    XCTAssertTrue(transformLocation.uri.pseudoPath.contains("Foundation.NSAffineTransform.swiftinterface"))
+    XCTAssertTrue(transformLocation.uri.scheme == "sourcekit-lsp")
+  }
 }
 
 private func assertSystemSwiftInterface(