Added support for new Eclipse JDT Python script

[manuel-uberti]

#864 changes how Eglot interacts with the Eclipse JDT LSP server by taking advantage of a recent addition to that server, a "friendly start up script". This finally makes the Eclipse JDT server function the same way as virtually all other servers that Eglot lists in eglot-server-programs for out-of-the-box support.

In practical terms, new versions of Eclipse JDT come with a new jdtls Python script that sets up the server with the default options Eglot needs to work with it.

Setup jdtls script

In order for jdtls to work, you will need:

• Eclipse JDT version 1.9.0. The jdtls program lives in the bin directory of the release archive found at http://download.eclipse.org/jdtls/milestones/.
• Python version 3.9 or later (see this comment).

For Eglot to use jdtls, make sure it is available in your $PATH environment variable. For instance:

$ ln -s $PATH_TO_JDT/bin/jdtls $HOME/local/bin/jdtls
$ chmod +x $HOME/local/bin/jdtls

In your Java projects, navigate to a java-mode file. You can now use M-x eglot and everything should be working as expected.

If something's off, please consider where the root of the problem might lie. Likely it's not Eglot, just that the jdtls script isn't performing correctly or you may need to add some arguments to its invocation.

(add-to-list 'eglot-server-programs '(java-mode "jdtls" "--some-option=somevalue"))

Refer to Eclipse JDT README for details.

Restore previous JDT interface in your .emacs or init.el

If, for some reason, you cannot make jdtls work on your system (e.g. you do not have access to a recent Python version), you
can easily restore the previous interface by adding some code to your .emacs or ~/.emacs.d/init.el initialization file.

;;; Setup specific to the Eclipse JDT setup in case one can't use the simpler 'jdtls' script
(with-eval-after-load 'eglot
  ;; Tell Eglot to use a specific class to handle java-mode files
  (add-to-list 'eglot-server-programs '(java-mode . eglot--eclipse-jdt-contact))

  (defun eglot--eclipse-jdt-contact (interactive)
    "Return cons (CLASS . ARGS) for connecting to Eclipse JDT.
If INTERACTIVE, prompt user for details."
    (cl-labels
        ((is-the-jar
           (path)
           (and (string-match-p
                 "org\\.eclipse\\.equinox\\.launcher_.*\\.jar$"
                 (file-name-nondirectory path))
                (file-exists-p path))))
      (let* ((classpath (or (getenv "CLASSPATH") path-separator))
             (cp-jar (cl-find-if #'is-the-jar (split-string classpath path-separator)))
             (jar cp-jar)
             (dir
              (cond
               (jar (file-name-as-directory
                     (expand-file-name ".." (file-name-directory jar))))
               (interactive
                (expand-file-name
                 (read-directory-name
                  (concat "Path to eclipse.jdt.ls directory (could not"
                          " find it in CLASSPATH): ")
                  nil nil t)))
               (t (error "Could not find eclipse.jdt.ls jar in CLASSPATH"))))
             (repodir
              (concat dir
                      "org.eclipse.jdt.ls.product/target/repository/"))
             (repodir (if (file-directory-p repodir) repodir dir))
             (config
              (concat
               repodir
               (cond
                ((string= system-type "darwin") "config_mac")
                ((string= system-type "windows-nt") "config_win")
                (t "config_linux"))))
             (workspace
              (expand-file-name (md5 (project-root (eglot--current-project)))
                                (locate-user-emacs-file
                                 "eglot-eclipse-jdt-cache"))))
        (unless jar
          (setq jar
                (cl-find-if #'is-the-jar
                            (directory-files (concat repodir "plugins") t))))
        (unless (and jar (file-exists-p jar) (file-directory-p config))
          (error "Could not find required eclipse.jdt.ls files (build required?)"))
        (when (and interactive (not cp-jar)
                   (y-or-n-p (concat "Add path to the server program "
                                     "to CLASSPATH environment variable?")))
          (setenv "CLASSPATH" (concat (getenv "CLASSPATH") path-separator jar)))
        (unless (file-directory-p workspace)
          (make-directory workspace t))
        (cons 'eglot-eclipse-jdt
              (list (executable-find "java")
                    "-Declipse.application=org.eclipse.jdt.ls.core.id1"
                    "-Dosgi.bundles.defaultStartLevel=4"
                    "-Declipse.product=org.eclipse.jdt.ls.core.product"
                    "-jar" jar
                    "-configuration" config
                    "-data" workspace)))))

  ;; Define said class and its methods
  (defclass eglot-eclipse-jdt (eglot-lsp-server) ()
    :documentation "Eclipse's Java Development Tools Language Server.")

  (cl-defmethod eglot-initialization-options ((server eglot-eclipse-jdt))
    "Passes through required JDT initialization options."
    `(:workspaceFolders
      [,@(cl-delete-duplicates
          (mapcar #'eglot--path-to-uri
                  (let* ((root (project-root (eglot--project server))))
                    (cons root
                          (mapcar
                           #'file-name-directory
                           (append
                            (file-expand-wildcards (concat root "*/pom.xml"))
                            (file-expand-wildcards (concat root "*/build.gradle"))
                            (file-expand-wildcards (concat root "*/.project")))))))
          :test #'string=)]
      ,@(if-let ((home (or (getenv "JAVA_HOME")
                           (ignore-errors
                             (expand-file-name
                              ".."
                              (file-name-directory
                               (file-chase-links (executable-find "javac"))))))))
            `(:settings (:java (:home ,home)))
          (ignore (eglot--warn "JAVA_HOME env var not set")))))

  (cl-defmethod eglot-execute-command
    ((_server eglot-eclipse-jdt) (_cmd (eql java.apply.workspaceEdit)) arguments)
    "Eclipse JDT breaks spec and replies with edits as arguments."
    (mapc #'eglot--apply-workspace-edit arguments)))

This effectively restores the code that #864 removed from eglot.el.

[jreicher]

I think -data still needs to be given? This is mentioned in the jdtls readme for running the script, but I've also noticed that the jdtls seems to get the project wrong if this isn't set (although I don't completely understand why).

[nemethf]

Wouldn't it make sense to extend the jdtls python script with the functionality of the removed elisp code? That is if no -data arg is given, create a cache directory at an appropriate location and pass that to the java_executable.

[manuel-uberti]

Following the discussion over at #1008 (comment), I added the relevant snippet of code to adjust -data in one's own configuration.

[NightMachinery]

Can the jdtls be installed via a script or a package manager?