Improve find definition of external files to consider opened files, avoiding exceptions.

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+- Only log server communication when trace-level matches.
+- Improve find definition of external files to consider opened files, avoiding exceptions.
+
 ## 2.4.4
 
 - Fix freeze after using paredit raise.

src/main/clojure/com/github/clojure_lsp/intellij/client.clj

@@ -30,7 +30,7 @@
       (let [response
             (case message-type
               (:parse-error :invalid-request)
-              (protocols.endpoint/log client :red "Error reading message" message)
+              (protocols.endpoint/log client :error "Error reading message" message)
               :request
               (protocols.endpoint/receive-request client context message)
               (:response.result :response.error)
@@ -41,18 +41,19 @@
         (when (identical? :request message-type)
           response))
       (catch Throwable e
-        (protocols.endpoint/log client :red "Error receiving:" e)
+        (protocols.endpoint/log client :error "Error receiving:" e)
         (throw e)))))
 
 (defrecord Client [client-id
                    input-ch
                    output-ch
                    join
                    request-id
-                   sent-requests]
+                   sent-requests
+                   trace-level]
   protocols.endpoint/IEndpoint
   (start [this context]
-    (protocols.endpoint/log this :white "lifecycle:" "starting")
+    (protocols.endpoint/log this :verbose "lifecycle:" "starting")
     (let [pipeline (async/pipeline-blocking
                     1 ;; no parallelism preserves server message order
                     output-ch
@@ -68,23 +69,25 @@
     ;; shut down
     join)
   (shutdown [this]
-    (protocols.endpoint/log this :white "lifecycle:" "shutting down")
+    (protocols.endpoint/log this :verbose "lifecycle:" "shutting down")
     ;; closing input will drain pipeline, then close output, then close
     ;; pipeline
     (async/close! input-ch)
     (if (= :done (deref join 10e3 :timeout))
-      (protocols.endpoint/log this :white "lifecycle:" "shutdown")
-      (protocols.endpoint/log this :red "lifecycle:" "shutdown timed out")))
+      (protocols.endpoint/log this :verbose "lifecycle:" "shutdown")
+      (protocols.endpoint/log this :verbose "lifecycle:" "shutdown timed out")))
   (log [this msg params]
-    (protocols.endpoint/log this :white msg params))
-  (log [_this _color msg params]
-    ;; TODO apply color
-    (logger/info (string/join " " [msg params])))
+    (protocols.endpoint/log this :verbose msg params))
+  (log [_this level msg params]
+    (when (or (identical? trace-level level)
+              (identical? trace-level :verbose))
+      ;; TODO apply color
+      (logger/info (string/join " " [msg params]))))
   (send-request [this method body]
     (let [req (lsp.requests/request (swap! request-id inc) method body)
           p (promise)
           start-ns (System/nanoTime)]
-      (protocols.endpoint/log this :cyan "sending request:" req)
+      (protocols.endpoint/log this :messages "sending request:" req)
       ;; Important: record request before sending it, so it is sure to be
       ;; available during receive-response.
       (swap! sent-requests assoc (:id req) {:request p
@@ -93,44 +96,45 @@
       p))
   (send-notification [this method body]
     (let [notif (lsp.requests/notification method body)]
-      (protocols.endpoint/log this :blue "sending notification:" notif)
+      (protocols.endpoint/log this :messages "sending notification:" notif)
       (async/>!! output-ch notif)))
   (receive-response [this {:keys [id] :as resp}]
     (if-let [{:keys [request start-ns]} (get @sent-requests id)]
       (let [ms (float (/ (- (System/nanoTime) start-ns) 1000000))]
-        (protocols.endpoint/log this :green (format "received response (%.0fms):" ms) resp)
+        (protocols.endpoint/log this :messages (format "received response (%.0fms):" ms) resp)
         (swap! sent-requests dissoc id)
         (deliver request (if (:error resp)
                            resp
                            (:result resp))))
-      (protocols.endpoint/log this :red "received response for unmatched request:" resp)))
+      (protocols.endpoint/log this :error "received response for unmatched request:" resp)))
   (receive-request [this context {:keys [id method params] :as req}]
-    (protocols.endpoint/log this :magenta "received request:" req)
+    (protocols.endpoint/log this :messages "received request:" req)
     (when-let [response-body (case method
                                "window/showMessageRequest" (show-message-request params)
                                "window/showDocument" (show-document context params)
                                "workspace/applyEdit" (workspace-apply-edit context params)
                                (logger/warn "Unknown LSP request method" method))]
       (let [resp (lsp.responses/response id response-body)]
-        (protocols.endpoint/log this :magenta "sending response:" resp)
+        (protocols.endpoint/log this :messages "sending response:" resp)
         resp)))
   (receive-notification [this context {:keys [method params] :as notif}]
-    (protocols.endpoint/log this :blue "received notification:" notif)
+    (protocols.endpoint/log this :messages "received notification:" notif)
     (case method
       "window/showMessage" (show-message context params)
       "$/progress" (progress context params)
       "textDocument/publishDiagnostics" (publish-diagnostics context params)
 
       (logger/warn "Unknown LSP notification method" method))))
 
-(defn client [in out]
+(defn client [in out trace-level]
   (map->Client
    {:client-id 1
     :input-ch (io-chan/input-stream->input-chan out)
     :output-ch (io-chan/output-stream->output-chan in)
     :join (promise)
     :sent-requests (atom {})
-    :request-id (atom 0)}))
+    :request-id (atom 0)
+    :trace-level trace-level}))
 
 (defn start-client! [client context]
   (protocols.endpoint/start client context))

src/main/clojure/com/github/clojure_lsp/intellij/extension/definition.clj

@@ -3,6 +3,7 @@
    :name com.github.clojure_lsp.intellij.extension.Definition
    :extends com.intellij.codeInsight.navigation.actions.GotoDeclarationHandlerBase)
   (:require
+   [clojure.java.io :as io]
    [clojure.string :as string]
    [com.github.clojure-lsp.intellij.action.references :as action.references]
    [com.github.clojure-lsp.intellij.client :as lsp-client]
@@ -33,19 +34,23 @@
       (let [v-file (file-system/create-temp-file project path text)]
         (definition->psi-element v-file project definition text)))))
 
-(defn ^:private show-definition [definition client project]
+(defn ^:private show-definition [definition ^VirtualFile current-v-file client project]
   (when-let [uri (:uri definition)]
     (if (string/starts-with? uri "jar:")
       (let [jar-pattern (re-pattern (str "^(jar|zip):(file:.+)!" (System/getProperty "file.separator") "(.+)"))]
         (dependency-content client uri project definition (last (re-find jar-pattern uri))))
       ;; TODO improve this
-      (if-let [v-file (util/uri->v-file uri)]
+      (if-let [v-file (or (util/uri->v-file uri)
+                          (when (= uri (.getUrl current-v-file)) current-v-file))]
         (definition->psi-element v-file project definition nil)
-        (dependency-content client uri project definition (string/replace-first uri (str "file://" (config/project-cache-path project)) ""))))))
+        (dependency-content client uri project definition
+                            (str (.relativize (.toPath (io/file (config/project-cache-path project)))
+                                              (.toPath (io/file (java.net.URI. uri))))))))))
 
 (defn -getGotoDeclarationTargets [_ ^PsiElement element _ ^Editor editor]
   (let [[line character] (:start (editor/text-range->range (.getTextRange element) editor))
-        project ^Project (.getProject editor)]
+        project ^Project (.getProject editor)
+        current-v-file (some-> element .getContainingFile .getVirtualFile)]
     (when-let [client (lsp-client/connected-client project)]
       (when-let [definition @(lsp-client/request! client [:textDocument/definition
                                                           {:text-document {:uri (editor/editor->uri editor)}
@@ -54,5 +59,5 @@
         (when-let [elements (if (and (= line (-> definition :range :start :line))
                                      (= character (-> definition :range :start :character)))
                               (action.references/get-references editor line character client)
-                              (show-definition definition client project))]
+                              (show-definition definition current-v-file client project))]
           (into-array PsiElement elements))))))

src/main/clojure/com/github/clojure_lsp/intellij/server.clj

@@ -93,11 +93,12 @@
 (defn ^:private spawn-server! [^Project project indicator server-path]
   (logger/info "Spawning LSP server process using path" server-path)
   (tasks/set-progress indicator "LSP: Starting server...")
-  (let [process (p/process [server-path "listen"]
+  (let [trace-level (keyword (db/get-in project [:settings :trace-level]))
+        process (p/process [server-path "listen"]
                            {:dir (.getBasePath project)
                             :env (EnvironmentUtil/getEnvironmentMap)
                             :err :string})
-        client (lsp-client/client (:in process) (:out process))]
+        client (lsp-client/client (:in process) (:out process) trace-level)]
     (db/assoc-in project [:server-process] process)
     (lsp-client/start-client! client {:progress-indicator indicator
                                       :project project})