Adding LSP features

Author: FastestMolasses

CodeEdit.xcodeproj/project.pbxproj

@@ -44,13 +44,16 @@ public struct AboutView: View {
         // if anyone knows of a better way to do this feel free to refactor
         .background(.regularMaterial.opacity(0))
         .background(EffectView(.popover, blendingMode: .behindWindow).ignoresSafeArea())
-        .background {
-            Button("") {
-                dismiss()
-            }
-            .keyboardShortcut(.escape, modifiers: [])
-            .hidden()
-        }
+//        .background {
+//            Button("") {
+//                dismiss()
+//            }
+//            .keyboardShortcut(.escape, modifiers: [])
+//            .hidden()
+//        }
+        .onExitCommand(perform: {
+            dismiss()
+        })
         .task {
             if let window = NSApp.findWindow(.about) {
                 window.styleMask = [.closable, .fullSizeContentView, .titled, .nonactivatingPanel]

CodeEdit/Features/About/Views/AboutView.swift

@@ -5,11 +5,12 @@
 //  Created by Pavel Kasila on 17.03.22.
 //
 
-import Foundation
 import AppKit
 import SwiftUI
 import Combine
+import Foundation
 import WindowManagement
+import LanguageServerProtocol
 
 @objc(WorkspaceDocument)
 final class WorkspaceDocument: NSDocument, ObservableObject, NSToolbarDelegate {
@@ -33,6 +34,7 @@ final class WorkspaceDocument: NSDocument, ObservableObject, NSToolbarDelegate {
 
     var utilityAreaModel = UtilityAreaViewModel()
     var searchState: SearchState?
+    var lspManager: LanguageServerManager?
     var quickOpenViewModel: QuickOpenViewModel?
     var commandsPaletteState: CommandPaletteViewModel?
     var listenerModel: WorkspaceNotificationModel = .init()
@@ -115,6 +117,17 @@ final class WorkspaceDocument: NSDocument, ObservableObject, NSToolbarDelegate {
             workspaceURL: url,
             editorManager: editorManager
         )
+        self.lspManager = LanguageServerManager()
+
+        // TODO: ACTIVATION EVENTS HERE
+        Task {
+            try await self.lspManager?.startServer(
+                for: .python,
+                projectURL: url,
+                workspaceFolders: [WorkspaceFolder(uri: url.absoluteString, name: "workspace_folder_name")]
+            )
+        }
+
         self.workspaceFileManager = .init(
             folderUrl: url,
             ignoredFilesAndFolders: Set(ignoredFilesAndDirectory),

CodeEdit/Features/Documents/WorkspaceDocument.swift

@@ -138,17 +138,21 @@ final class Editor: ObservableObject, Identifiable {
     ///   - file: the file to open.
     ///   - asTemporary: indicates whether the tab should be opened as a temporary tab or a permanent tab.
     func openTab(file: CEWorkspaceFile, asTemporary: Bool) {
+        print("Attempting to open file: \(file.url)")
         let item = EditorInstance(file: file)
         // Item is already opened in a tab.
         guard !tabs.contains(item) || !asTemporary else {
             selectedTab = item
             history.prepend(item)
+            print("File already opened!")
             return
         }
 
         switch (temporaryTab, asTemporary) {
         case (.some(let tab), true):
+            print("Temporary tab 1")
             if let index = tabs.firstIndex(of: tab) {
+                print("Going inside 1")
                 history.prepend(item)
                 tabs.remove(tab)
                 tabs.insert(item, at: index)
@@ -157,24 +161,21 @@ final class Editor: ObservableObject, Identifiable {
             }
 
         case (.some(let tab), false) where tab == item:
+            print("2")
             temporaryTab = nil
 
         case (.none, true):
+            print("3")
             openTab(file: item.file)
             temporaryTab = item
 
         case (.none, false):
+            print("4")
             openTab(file: item.file)
 
         default:
             break
         }
-// TODO: IS THIS NEEDED? openFile ALREADY GETS CALLED INSIDE openTab
-//        do {
-//            try openFile(item: item)
-//        } catch {
-//            print(error)
-//        }
     }
 
     /// Opens a tab in the editor.
@@ -184,11 +185,16 @@ final class Editor: ObservableObject, Identifiable {
     ///   - fromHistory: Indicates whether the tab has been opened from going back in history.
     func openTab(file: CEWorkspaceFile, at index: Int? = nil, fromHistory: Bool = false) {
         let item = Tab(file: file)
+        print("Tabs before update: \(tabs)")
         if let index {
             tabs.insert(item, at: index)
         } else {
             tabs.append(item)
         }
+
+        print("Updated tabs: \(tabs)")
+        print("New item: \(item.file.url)")
+
         selectedTab = item
         if !fromHistory {
             history.removeFirst(historyOffset)
@@ -198,12 +204,14 @@ final class Editor: ObservableObject, Identifiable {
         do {
             try openFile(item: item)
         } catch {
+            print("openFile error")
             print(error)
         }
     }
 
     private func openFile(item: Tab) throws {
         guard item.file.fileDocument == nil else {
+            print("File document is nil, returning!")
             return
         }
 
@@ -216,6 +224,7 @@ final class Editor: ObservableObject, Identifiable {
         )
         item.file.fileDocument = codeFile
         CodeEditDocumentController.shared.addDocument(codeFile)
+        print("Successfully opened file")
     }
 
     func goBackInHistory() {

CodeEdit/Features/Editor/Models/Editor.swift

@@ -30,8 +30,6 @@ class EditorManager: ObservableObject {
     /// History of last-used editors.
     var activeEditorHistory: Deque<() -> Editor?> = []
 
-    var fileDocuments: [CEWorkspaceFile: CodeFileDocument] = [:]
-
     /// notify listeners whenever tab selection changes on the active editor.
     var tabBarTabIdSubject = PassthroughSubject<String?, Never>()
     var cancellable: AnyCancellable?
@@ -74,7 +72,7 @@ class EditorManager: ObservableObject {
     ///   - editor: The editor to add the tab to. If nil, it is added to the active tab group.
     func openTab(item: CEWorkspaceFile, in editor: Editor? = nil) {
         let editor = editor ?? activeEditor
-        editor.openTab(file: item)
+        editor.openTab(file: item, asTemporary: false)
     }
 
     /// bind active tap group to listen to file selection changes.

CodeEdit/Features/Editor/Models/EditorManager.swift

@@ -78,7 +78,7 @@ class LSPCache {
             self.evictIfNeeded()
         }
     }
-    
+
     private func evictIfNeeded() {
         evictionQueue.async(flags: .barrier) {
             while self.cacheEntriesOrder.count > self.cacheSizeLimit {

CodeEdit/Features/LSP/LSPCache.swift

@@ -0,0 +1,61 @@
+//
+//  LSPUtil.swift
+//  CodeEdit
+//
+//  Created by Abe Malla on 2/10/24.
+//
+
+import Foundation
+import LanguageServerProtocol
+
+/// Helper function to get the edits from a completion item
+/// - Parameters:
+///  - startPosition: The position where the completion was requested
+///  - item: The completion item
+///  - Returns: An array of TextEdit objects
+func getCompletionItemEdits(startPosition: Position, item: CompletionItem) -> [TextEdit] {
+    var edits: [TextEdit] = []
+
+    // If a TextEdit or InsertReplaceEdit value was provided
+    if let edit = item.textEdit {
+        switch edit {
+        case .optionA(let textEdit):
+            edits.append(textEdit)
+        case .optionB(let insertReplaceEdit):
+            edits.append(
+                TextEdit(range: insertReplaceEdit.insert, newText: insertReplaceEdit.newText)
+            )
+            edits.append(
+                TextEdit(range: insertReplaceEdit.replace, newText: insertReplaceEdit.newText)
+            )
+        }
+    }
+    // If the `insertText` value was provided
+    else if let insertText = item.insertText {
+        // TODO: COMPUTE EDIT BY FINDING MATCHING TEXT, ALSO CHECK FOR TRIGGER CHARACTERS
+        edits.append(
+            TextEdit(
+                range: LSPRange(from: startPosition, offsetCharacter: insertText.count),
+                newText: insertText
+            )
+        )
+    }
+    // Fallback to the label
+    else if item.label != "" {
+        // TODO: COMPUTE EDIT BY FINDING MATCHING TEXT, ALSO CHECK FOR TRIGGER CHARACTERS
+        edits.append(
+            TextEdit(
+                range: LSPRange(from: startPosition, offsetCharacter: item.label.count),
+                newText: item.label
+            )
+        )
+    }
+
+    // If additional edits were provided
+    // An example would be to also include an 'import' statement at the top of the file
+    if let additionalEdits = item.additionalTextEdits {
+        edits.append(contentsOf: additionalEdits)
+    }
+
+    return edits
+}

CodeEdit/Features/LSP/LSPUtil.swift

@@ -0,0 +1,75 @@
+//
+//  LanguageClient+CallHierarchy.swift
+//  CodeEdit
+//
+//  Created by Abe Malla on 2/7/24.
+//
+
+import Foundation
+import LanguageServerProtocol
+
+extension LanguageServer {
+    func requestPrepareCallHierarchy(
+        document documentURI: String, _ position: Position
+    ) async -> CallHierarchyPrepareResponse {
+        // TODO: SOMEHOW NEED TO INVALIDATE THIS. CURRENTLY STORING EVERYTHING IN callHierarchyItems VARIABLE
+//        let prepareParams = CallHierarchyPrepareParams(
+//            textDocument: TextDocumentIdentifier(uri: documentURI),
+//            position: position,
+//            workDoneToken: nil
+//        )
+//
+//        do {
+//            guard let items = try await server.prepareCallHierarchy(params: prepareParams) else {
+//                return []
+//            }
+//            callHierarchyItems[documentURI] = items
+//            return items
+//        } catch {
+//            // TODO: LOGGING
+//            print("requestPrepareCallHierarchy: Error \(error)")
+//        }
+
+        return []
+    }
+
+    func requestCallHierarchyIncomingCalls(
+        _ callHierarchyItem: CallHierarchyItem
+    ) async -> CallHierarchyIncomingCallsResponse {
+//        let incomingParams = CallHierarchyIncomingCallsParams(
+//            item: callHierarchyItem,
+//            workDoneToken: nil
+//        )
+//
+//        do {
+//            guard let incomingCalls = try await server.callHierarchyIncomingCalls(params: incomingParams) else {
+//                return []
+//            }
+//            return incomingCalls
+//        } catch {
+//            // TODO: LOGGING
+//            print("requestCallHierarchyIncomingCalls: Error \(error)")
+//        }
+        return []
+    }
+
+    func requestCallHierarchyOutgoingCalls(
+        _ callHierarchyItem: CallHierarchyItem
+    ) async -> CallHierarchyOutgoingCallsResponse {
+        let outgoingParams = CallHierarchyOutgoingCallsParams(
+            item: callHierarchyItem,
+            workDoneToken: nil
+        )
+
+        do {
+            guard let outgoingCalls = try await lspInstance.callHierarchyOutgoingCalls(outgoingParams) else {
+                return []
+            }
+            return outgoingCalls
+        } catch {
+            // TODO: LOGGING
+            print("requestCallHierarchyOutgoingCalls: Error \(error)")
+        }
+        return []
+    }
+}

CodeEdit/Features/LSP/LanguageClient+CallHierarchy.swift

@@ -0,0 +1,19 @@
+//
+//  LanguageClient+CodeLens.swift
+//  CodeEdit
+//
+//  Created by Abe Malla on 2/7/24.
+//
+
+import Foundation
+import LanguageServerProtocol
+
+extension LanguageServer {
+//    func requestCodeLens() async -> CodeLensResponse {
+//
+//    }
+//
+//    func requestCodeLensResolve() async -> CodeLensResolveResponse {
+//
+//    }
+}

CodeEdit/Features/LSP/LanguageClient+CodeLens.swift

@@ -0,0 +1,28 @@
+//
+//  LanguageClient+ColorPresentation.swift
+//  CodeEdit
+//
+//  Created by Abe Malla on 2/7/24.
+//
+
+import Foundation
+import LanguageServerProtocol
+
+extension LanguageServer {
+    func requestColorPresentation(document documentURI: String, _ color: Color, _ range: LSPRange) async -> ColorPresentationResponse {
+        let params = ColorPresentationParams(
+            workDoneToken: nil,
+            partialResultToken: nil,
+            textDocument: TextDocumentIdentifier(uri: documentURI),
+            color: color,
+            range: range
+        )
+        do {
+            return try await lspInstance.colorPresentation(params)
+        } catch {
+            // TODO: LOGGING
+            print("requestColorPresentation: Error \(error)")
+        }
+        return []
+    }
+}