Potential issue of lsp-julia--rls-command

[xukai92]

I'm a bit confused of the function, especially this part https://github.com/non-Jedi/lsp-julia/blob/master/lsp-julia.el#L279-L289

In short, this essentially gives something like

julia --startup-file=no --history-file=no -eimport Pkg; Pkg.instantiate(); ...

instead of

julia --startup-file=no --history-file=no -e 'import Pkg; Pkg.instantiate(); ...'

i.e. the quotation is missing.

How the current master is working at all?

PS: I found this when making lsp-julia work over TRAMP, which I have to add the quotation around all the part after -e to make things work.

[gdkrmr]

How the current master is working at all?

Magic? :-)

Thanks for noting, if you have already fixed it, could you make a PR?

[xukai92]

Actually adding quotes would fail the local version, but works with the TRAMP version.
For more context, here are the related codes for the TRAMP version (note the "'" I added around the body codes)

  (defun lsp-julia--rls-command-remote ()
    "The command to lauch the Julia Language Server."
    `(,lsp-julia-command
      ,@lsp-julia-flags
      ,(concat "-e "
               "'"
               "import Pkg; Pkg.instantiate(); "
               "using InteractiveUtils, Sockets, SymbolServer, LanguageServer; "
               "Union{Int64, String}(x::String) = x; "
               "server = LanguageServer.LanguageServerInstance("
               "stdin, stdout, "
               (lsp-julia--get-root-remote) ", "
               (lsp-julia--get-depot-path) ", "
               "nothing, "
               (lsp-julia--symbol-server-store-path-to-jl-no-expand) "); "
               "run(server);"
               "'")))

  (lsp-register-client
    (make-lsp-client :new-connection (lsp-tramp-connection 'lsp-julia--rls-command-remote)
                     :major-modes '(julia-mode ess-julia-mode)
                     :server-id 'julia-ls-remote
                     :remote? t))

Here lsp-julia--get-root-remote and lsp-julia--symbol-server-store-path-to-jl-no-expand are just some of my work-arounds to handle TRAMP path.
This version works well for me.

However, if I use the same quotes in the local version, i.e.

 (defun lsp-julia--rls-command()
    "The command to lauch the Julia Language Server."
    `(,lsp-julia-command
      ,@lsp-julia-flags
      ,(concat "-e "
               "'"
               "import Pkg; Pkg.instantiate(); "
               "using InteractiveUtils, Sockets, SymbolServer, LanguageServer; "
               "Union{Int64, String}(x::String) = x; "
               "server = LanguageServer.LanguageServerInstance("
               "stdin, stdout, "
               (lsp-julia--get-root) ", "
               (lsp-julia--get-depot-path) ", "
               "nothing, "
               (lsp-julia--symbol-server-store-path-to-jl) "); "
               "run(server);"
               "'")))

I would get

Process julia-ls stderr finished
ERROR: syntax: cannot juxtapose string literal
Stacktrace:
 [1] top-level scope
   @ none:1

I think it might trace down to the difference between lsp-stdio-connection and lsp-tramp-connection, which call the rls-command? :|

[gdkrmr]

How is your setup? I have never gotten lsp-julia to work with remote projects. You open a file from a julia project on the remote server and want the language server to spawn that same server? Is it possible to have a local language server work on the remote files?

lsp-tramp-connection is provided by lsp-mode, right?

[xukai92]

How is your setup?

This is my full setup (contains hacks/bugfixes collected from multiple places, see my comments in codes)

FULL SETUP

;; Julia over TRAMP
(after! tramp
  ;; Ignore "Remote file error: Forbidden reentrant call of Tramp"
  ;; Ref: https://www.gnu.org/software/tramp/
  (setq debug-ignored-errors
        (cons 'remote-file-error debug-ignored-errors))

  (add-to-list 'tramp-remote-path "~/bin")
  (add-to-list 'tramp-remote-path 'tramp-own-remote-path))

;; To make lsp-mode work over TRAMP
;; Ref: https://github.com/emacs-lsp/lsp-mode/pull/2531
(after! tramp
  (defun lsp-tramp-connection (local-command &optional generate-error-file-fn)
  "Create LSP stdio connection named name.
LOCAL-COMMAND is either list of strings, string or function which
returns the command to execute."
  ;; 2.5.0-pre (as built from native-comp branch before M Albinus released tramp-2.5)
  ;; worked fine
  (defvar tramp-version)
  (defvar tramp-connection-properties)
  (when (version< tramp-version "2.5.0-pre")
    (lsp-warn
     "Your tramp version - %s - might fail to work with remote LSP. Update to version 2.5 or greater (available on elpa)"
     tramp-version))
  ;; Force a direct asynchronous process.
  (add-to-list 'tramp-connection-properties
               (list (regexp-quote (file-remote-p default-directory))
                     "direct-async-process" t))
  (list :connect (lambda (filter sentinel name environment-fn)
                   (let* ((final-command (lsp-resolve-final-function
                                          local-command))
                          (stderr-buf (or (when generate-error-file-fn
                                            (funcall generate-error-file-fn name))
                                          (format "/tmp/%s-%s-stderr" name
                                                  (cl-incf lsp--stderr-index))))
                          (process-name (generate-new-buffer-name name))
                          (process-environment
                           (lsp--compute-process-environment environment-fn))
                          (proc (make-process
                                 :name process-name
                                 :buffer (format "*%s*" process-name)
                                 :command final-command
                                 :connection-type 'pipe
                                 :coding 'no-conversion
                                 :noquery t
                                 :filter filter
                                 :sentinel sentinel
                                 :stderr stderr-buf
                                 :file-handler t)))
                     (cons proc proc)))
        :test? (lambda () (-> local-command lsp-resolve-final-function
                              lsp-server-present?)))))

;; Register lsp-julia for remote mode
(after! lsp-julia
  (defun lsp-julia--get-root-remote ()
    "Get the (Julia) project root directory of the current file over TRAMP."
    (concat "\""
            (tramp-file-name-localname
              (tramp-dissect-file-name
                (expand-file-name
                  (or (locate-dominating-file default-directory "Project.toml")
                      (locate-dominating-file default-directory "JuliaProject.toml")
                      lsp-julia-default-environment))))
            "\""))

  (defun lsp-julia--symbol-server-store-path-to-jl-no-expand ()
    "Convert the variable `lsp-julia-symbol-server-store-path' to a
    string or \"nothing\" if `nil'"
    (if lsp-julia-symbol-server-store-path
        (let ((sssp lsp-julia-symbol-server-store-path))
          (make-directory sssp t)
          (concat "\"" sssp "\""))
      "nothing"))

  (defun lsp-julia--rls-command-remote ()
    "The command to lauch the Julia Language Server."
    `(,lsp-julia-command
      ,@lsp-julia-flags
      ,(concat "-e "
               "'"
               "import Pkg; Pkg.instantiate(); "
               "using InteractiveUtils, Sockets, SymbolServer, LanguageServer; "
               "Union{Int64, String}(x::String) = x; "
               "server = LanguageServer.LanguageServerInstance("
               "stdin, stdout, "
               (lsp-julia--get-root-remote) ", "
               (lsp-julia--get-depot-path) ", "
               "nothing, "
               (lsp-julia--symbol-server-store-path-to-jl-no-expand) "); "
               "run(server);"
               "'")))

  (lsp-register-client
    (make-lsp-client :new-connection (lsp-tramp-connection 'lsp-julia--rls-command-remote)
                     :major-modes '(julia-mode ess-julia-mode)
                     :server-id 'julia-ls-remote
                     ;;:multi-root t
                     :remote? t)))

This setup pataches a recent PR in lsp-mode.
Along with this, you have to upgrade TRAMP to 2.5.0.
The setup for the lsp-julia is straightfoward -- only need to make sure all pathes are the remote ones.

You open a file from a julia project on the remote server and want the language server to spawn that same server?

Exactly. My config above does this.

Is it possible to have a local language server work on the remote files?

I don't know but I suppose this would be hard as the dependencies are on the remote.

lsp-tramp-connection is provided by lsp-mode, right?

Yes :)

[tecosaur]

@xukai92 I've just come across this thread after looking for a way to get a remote lsp server working. Do you think your work could be turned into a PR?

[ordicker]

Making lsp-julia works remotely won't be great.

[gdkrmr]

I have tried #61 and it doesn't work locally. I think emacs calls julia --project=... is a single command. I have also tried creating a single string and calling that with the same result.

I have also tried implementing the solution by @xukai92 and get the same error on the remote machine. maybe this is a path issue, I didn't have time to check.

[uncomfyhalomacro]

I just saw this issue. I made a script for this instead to fix some corner cases https://codeberg.org/uncomfyhalomacro/erudite-macs/src/branch/main/scripts. and to use that, i made a this huge elisp code

(with-eval-after-load "lsp-julia"
      (add-to-list 'lsp-language-id-configuration '(julia-ts-mode . "julia"))
      (setq
       lsp-julia-command "julia"
       lsp-julia-package-dir "@emacs-lspconfig"
       lsp-julia-flags `(,(concat "--project=" lsp-julia-package-dir)
                         "--startup-file=no"
                         "--history-file=no"
                         ,(concat "-J" (shell-command-to-string "julia --startup-file=no --history-file=no -e 'print(homedir())'") "/.julia/environments/emacs-lspconfig/languageserver.so"))
       lsp-julia-default-environment (string-trim(shell-command-to-string "julia --startup-file=no --history-file=no -e 'print(dirname(Base.active_project()))'")))

      (defun lsp-julia-update-languageserver()
        "Custom command to update the Julia Language Server."
        (interactive)
        (setq lsp-julia-update-flags `(,(concat "--project=" lsp-julia-package-dir)
                                       "--startup-file=no"
                                       "--history-file=no"))
        (apply 'start-process
               "lsp-julia-languageserver-updater"
               "*lsp-julia-languageserver-updater*"
               lsp-julia-command
               (append lsp-julia-update-flags
                       (list (expand-file-name "scripts/julia-ls-update-or-install.jl" user-emacs-directory)))))

      (defun lsp-julia--get-root ()
        "Get the (Julia) project root directory of the current file. Customized."
        (concat ""
                (expand-file-name
                 (or (locate-dominating-file buffer-file-name "Project.toml")
                     (locate-dominating-file buffer-file-name "JuliaProject.toml")
                     lsp-julia-default-environment))
                ""))

      (defvar julia-ls-script "" "Path to Julia Script")

      (setq julia-ls-script
            (expand-file-name "scripts/julia-ls.jl" user-emacs-directory))

      (defun lsp-julia--rls-command ()
        "This is a custom command to launch the Julia Language Server.
                   The reason being that I am using Julia inside a distrobox."
        `(,lsp-julia-command
          ,@lsp-julia-flags
          ,julia-ls-script
          ,(buffer-file-name)))
      (lsp-register-client
       (make-lsp-client :new-connection (lsp-tramp-connection 'lsp-julia--rls-command)
                        :activation-fn (lsp-activate-on "julia")
                        :major-modes '(julia-mode julia-ts-mode)
                        :remote? t
                        :priority '1
                        :server-id 'lsp-julia-remote))
      (lsp-register-client
       (make-lsp-client :new-connection (lsp-stdio-connection 'lsp-julia--rls-command)
                        :major-modes '(julia-mode julia-ts-mode)
                        :server-id 'julia-ls
                        :multi-root t))
      ))

[alecStewart1]

To expand upon what @uncomfyhalomacro has, I have the following For julia-ts-mode, JuliaFormatter with apheleia, julia-snail and lsp-julia:

(use-package julia-ts-mode
  :ensure (julia-ts-mode
           :repo "https://github.com/dhanak/julia-ts-mode"
           :branch "main")
  :interpreter "julia"
  :mode "\\.jl\\'"
  :config
  ;; Borrow matlab.el's fontification of math operators. From
  ;; <https://web.archive.org/web/20170326183805/https://ogbe.net/emacsconfig.html>
  (font-lock-add-keywords
   'julia-ts-mode
   `((,(let ((OR "\\|"))
         (concat "\\("  ; stolen `matlab.el' operators first
                 ;; `:` defines a symbol in Julia and must not be highlighted
                 ;; as an operator. The only operators that start with `:` are
                 ;; `:<` and `::`. This must be defined before `<`.
                 "[:<]:" OR
                 "[<>]=?" OR
                 "\\.[/*^']" OR
                 "===" OR
                 "==" OR
                 "=>" OR
                 "\\<xor\\>" OR
                 "[-+*\\/^&|$]=?" OR  ; this has to come before next (updating operators)
                 "[-^&|*+\\/~]" OR
                 ;; Julia variables and names can have `!`. Thus, `!` must be
                 ;; highlighted as a single operator only in some
                 ;; circumstances. However, full support can only be
                 ;; implemented by a full parser. Thus, here, we will handle
                 ;; only the simple cases.
                 "[[:space:]]!=?=?" OR "^!=?=?" OR
                 ;; The other math operators that starts with `!`.
                 ;; more extra julia operators follow
                 "[%$]" OR
                 ;; bitwise operators
                 ">>>" OR ">>" OR "<<" OR
                 ">>>=" OR ">>" OR "<<" OR
                 "\\)"))
      1 font-lock-type-face)))

  (defconst julia:faster-startup-flags
    '("--startup-file=no"
      "--history-file=no"
      "--color=no")
    "Startup flags for Julia processes to speed things up.")

  (defvar julia:default-environment
    (string-trim
     (shell-command-to-string
      "julia --compile=min --optimize=0 --startup-file=no --history-file=no --color=no -e 'print(dirname(Base.active_project()))'"))
    "The current Julia environment/project")

  ;; TODO Figure out how to cheat and make formatting even faster with
  ;; --trace-compile to get a list of functions that are compiled by Julia, and
  ;; PackageCompiler.jl to create a sysimage for JuliaFormatter.

  (defconst julia:format-sysimage
    (expand-file-name "~/.local/bin/juliaformatter.so")
    "Path to sysimage for JuliaFormatter.")

  (defvar julia:format-command
    `(,(executable-find "julia")
      ,(concat "--project=" julia:default-environment)
      "--compile=min"
      "--optimize=0"
      ,@julia:faster-startup-flags
      ,(if (file-exists-p julia:format-sysimage)
           (concat "-J" julia:format-sysimage))
      ,(concat "-e \"using JuliaFormatter "
               (if (locate-dominating-file buffer-file-name ".JuliaFormatter.toml")
                   (concat "format_file(\'" (buffer-file-name) "\')\"")
                 (concat "format_file(\'" (buffer-file-name) "\', BlueStyle())\""))))
    "List of string for Julia’s JuliaFormatter package to pass to ‘apheleia’.")


  (push '(julia-formatter julia:format-command)
        apheleia-formatters))

(use-package julia-snail
  :requires vterm
  :after julia-ts-mode
  :hook (julia-ts-mode . julia-snail-mode)
  :custom
  (julia-snail-terminal-type :vterm))

(use-package lsp-julia
  :after lsp-mode
  :hook (julia-ts-mode . lsp)
  :preface
  (defvar lsp-julia:main-env
    (expand-file-name
     (concat "~/.julia/environments/"
             (string-trim
              (shell-command-to-string
               "julia --version | cut -d' ' -f3"))
             "/")))

  (defconst lsp-julia:emacs-env
    (expand-file-name "~/.julia/environments/emacs/")
    "The julia environment for install LanguageServer.jl.")

  ;; TODO should scripts be
  ;; - compiled, or
  ;; - use --optimize

  (defconst lsp-julia:ls-install-script
    (expand-file-name "~/.local/bin/julia-ls-maybe-install.jl")
    "Path to custom script to install or update the Julia language server.")

  (defconst lsp-julia:ls-script
    (expand-file-name "~/.local/bin/julia-ls.jl")
    "Path to custom script to run the Julia language server.")

  (defun lsp-julia:get-root ()
    "Locate the root project file for a Julia project."
    (expand-file-name
     (or (locate-dominating-file buffer-file-name "Project.toml")
         (locate-dominating-file buffer-file-name "JuliaProject.toml")
         lsp-julia-default-environment)))

  (defun lsp-julia:maybe-install-language-server ()
    "Command to run to update or install the Julia language server."
    (interactive)
    (let ((flags `(,(concat "--project=" lsp-julia-package-dir) ,@julia:faster-startup-flags)))
      (apply #'start-process
             "lsp-julia:maybe-install-language-server"
             "*lsp-julia:maybe-install-language-server*"
             lsp-julia-command
             `(,@flags lsp-julia:ls-install-script))))

  (defun lsp-julia:rls-command ()
    "TODO"
    `(,lsp-julia-command
      ,@lsp-julia-flags
      ,lsp-julia:ls-script
      ,(buffer-file-name)))
  :init
  (if (not (file-directory-p lsp-julia:main-env))
      (make-directory lsp-julia:main-env t))
  (if (not (file-directory-p lsp-julia:emacs-env))
      (make-directory lsp-julia:emacs-env t))
  (general-setq lsp-julia-default-environment nil)
  :custom
  (lsp-julia-command (executable-find "julia"))
  (lsp-julia-package-dir "@emacs")
  (lsp-julia-flags `(,(concat "--project=" lsp-julia-package-dir)
                     ,@lsp-julia:faster-startup-flags
                     ,(concat "-J" lsp-julia:emacs-env "/languageserver.so")))
  (lsp-julia-default-environment julia:default-environment)
  :config
  (setq-mode-local julia-ts-mode
                   lsp-enable-folding t
                   lsp-folding-range-limit 100)

  (add-to-list 'lsp-language-id-configuration '(julia-mode . "julia"))
  (add-to-list 'lsp-language-id-configuration '(julia-ts-mode . "julia"))
  
  (lsp-register-client
   (make-lsp-client :new-connection (lsp-stdio-connection #'lsp-julia:rls-command)
                    :major-modes '(julia-mode julia-ts-mode)
                    :activation-fn (lsp-activate-on "julia")
                    :server-id 'julia-ls
                    :download-server-fn #'lsp-julia:maybe-install-language-server
                    :multi-root t)))

(You can view the full file here.)

Scripts are the same as the ones @uncomfyhalomacro has.

Whether or not this is "perfect" or "optimal" I'm unsure yet. I'm beginning to look into Julia for work purposes, so I would like to have this working and I'll try to expand upon this in the future. I am getting this warning:

LSP :: There are no language servers supporting current mode `julia-ts-mode' registered with `lsp-mode'.
This issue might be caused by:
1. The language you are trying to use does not have built-in support in `lsp-mode'. You must install the required support manually. Examples of this are `lsp-java' or `lsp-metals'.
2. The language server that you expect to run is not configured to run for major mode `julia-ts-mode'. You may check that by checking the `:major-modes' that are passed to `lsp-register-client'.
3. `lsp-mode' doesn't have any integration for the language behind `julia-ts-mode'. Refer to https://emacs-lsp.github.io/lsp-mode/page/languages and https://langserver.org/ .
4. You are over `tramp'. In this case follow https://emacs-lsp.github.io/lsp-mode/page/remote/.
5. You have disabled the `lsp-mode' clients for that file. (Check `lsp-enabled-clients' and `lsp-disabled-clients').
You can customize `lsp-warn-no-matched-clients' to disable this message.

So I'm definitely missing something.

[uncomfyhalomacro]

You might want to take a look again the following lines of code https://codeberg.org/uncomfyhalomacro/erudite-macs/src/commit/c4329a1bc7ddb5b2a67a2fbeb9773c9cb9aab815/modules/erudite-languages.el#L114-L172 @alecStewart1. not sure but i feel like i did it that way so it will load correctly.

[alecStewart1]

You might want to take a look again the following lines of code https://codeberg.org/uncomfyhalomacro/erudite-macs/src/commit/c4329a1bc7ddb5b2a67a2fbeb9773c9cb9aab815/modules/erudite-languages.el#L114-L172 @alecStewart1. not sure but i feel like i did it that way so it will load correctly.

See funny thing is that what you have should work, but so should what I have. With :after and :config, lsp-julia should be loaded after lsp-mode.

I'm using elpaca as well, so maybe there's something I'm missing. I'm guessing I should just do :after lsp-mode and then in the :config block have (add-hook 'julia-ts-mode-hook #'lsp).

EDIT: Okay, I think one issue was that julia-ts-mode-hook did not exist, so I created a hook variable in a :preface block and then set that hook to initially have what julia-mode-hook has in it if has anything. treesit-auto even recommends this.

[mortang2410]

The repo has not been updated for 2 years.

I have personally fixed it with the following elisp code. I can not guarantee it will work for others. I am using Doom Emacs on Ubuntu 25.04.

julia_1.txt

It basically overwrites the broken functions from the repo, and uses a script file instead of quoting.

1. load the elisp code
2. run M-: (lsp-julia--rls-command) at least once to see that it correctly returns something
3. find the file from the output, something like ~/.config/emacs/.local/cache/lsp-julia/start-language-server.jl. Run julia manually from your shell and run those commands manually at least once to set up everything
4. Now LSP should work in lsp-julia and Doom Emacs.

[gdkrmr]

I use doom emacs and it works for me. I don't do any special configuration.