Can't get Eglot + JDTLS to work

[rpaufin]

This is how I install Eglot:

(use-package eglot
  :hook ((c-mode c++-mode java-mode shell-script-mode) . eglot-ensure)
  :config
  (setq eglot-autoshutdown t))

I'm using the system-installed JDTLS, so not a local one.
When I try creating a file, for example ~/test.java, and write something in it to see if Eglot works, all that happens is I get this message (or some variation of it, that long sequence of characters keeps changing every time I type something):

[eglot] rpaufin 149b0a5a-9a98-4cdc-8fa6-7b4942ce807e: | Building Building

Other than that, nothing. No Flymake diagnostics, no completions.
I thought there was something wrong with the server, so I tested it in Neovim using nvim-jdtls with the quickstart configuration and it worked just fine - it ran diagnostics, listed errors, etc. So I'm not sure what the problem is exactly.

Here's the Eglot log, I have no idea how to decipher it: java.log

And by the way, I did test the C and C++ modes using clangd and had no issues.

[joaotavora]

As far as I understand, the Java language server has to build your project, and maybe just ~/test.java isn't a very good way to make a buildable java project? I haven't programmed Java in a million years, but I'd say at least a ~/test-project/test.java maybe with a Git-initialized .git directory is a better experiment? Create such a minimal project and try it with both Eglot and Neovim. If you're still stumped, follow the instructions of https://joaotavora.github.io/eglot/#Troubleshooting-Eglot and make a bug report.

[rpaufin]

Doesn't work, unfortunately. I'll send a bug report.

[joaotavora]

Thanks. If Neovim works with the same simple project you're going to use as an example in your report and it supplies you with anything resembling an LSP JSONRPC transcript or log, please also attach that transcript in your report.

[rpaufin]

I retract my statement.
Right when I was about to send the report I saw the logs complaining about the file I'm editing not existing, so I tried creating it before opening it with Emacs, which showed different errors, this time about /home/user/.config/emacs/elpa/gnupg/S.gpg-agent. not existing (yes, with a dot in the end), so I added that file and things DID work, but that's obviously not right, so...

Basically, after some playing around I commented out nearly my entire config + deleted my elpa and eln-cache directories, managed to make Eglot work by doing exactly what you suggested (except for git init, that wasn't necessary) - and I don't know why that didn't work before - and then slowly uncommented small chunks of my config at a time to see if Eglot still works. Nothing from my config had to be removed after all.

So, to sum it all up, yes, after ripping out parts of your config and reinstalling everything, creating a dedicated directory and touching the file before opening it with Emacs does work.
Investigating this was pretty fun. Thank you for your work o7

By the way - The Neovim extension I was talking about seems to actually create the files before the LSP turns on. Maybe Eglot should try do that too for Java files? I don't know if this is something project.el/Projectile take care of, since I don't use them.

[joaotavora]

So, to sum it all up, yes, after ripping out parts of your config and reinstalling everything, creating a dedicated directory and touching the file before opening it with Emacs does work.

Ah, interesting. It seems that the Eclipse jdtls language server cannot deal with LSP documents that don't yet have a physical representation on disk. Other (most?) language servers deal with this fine (just tested with clangd, for example). I'd say this is a server bug.

Right when I was about to send the report I saw the logs complaining about the file I'm editing not existing,

Where exactly do you see this? I can't see it in the attached java.log.

[rpaufin]

Where exactly do you see this? I can't see it in the attached java.log.

Weird, but it did appear other times.
Here's another log: java-new.log
EDIT: HERE is another log: java-new-improved.log
I'm really bad at this.

[zsxh]

Example for jdtls user

How Eglot launch JDTLS

(require 'eglot)

(defun jdtls-command-contact (&optional interactive)
  (let* ((jdtls-cache-dir (file-name-concat user-emacs-directory "cache" "lsp-cache"))
         (project-dir (file-name-nondirectory (directory-file-name (project-root (project-current)))))
         (data-dir (expand-file-name (file-name-concat jdtls-cache-dir (md5 project-dir))))
         (jvm-args `(,(concat "-javaagent:" (expand-file-name "~/.m2/repository/org/projectlombok/lombok/1.18.20/lombok-1.18.20.jar"))
                     "-Xmx8G"
                     ;; "-XX:+UseG1GC"
                     "-XX:+UseZGC"
                     "-XX:+UseStringDeduplication"
                     ;; "-XX:FreqInlineSize=325"
                     ;; "-XX:MaxInlineLevel=9"
                     "-XX:+UseCompressedOops"))
         (jvm-args (mapcar (lambda (arg) (concat "--jvm-arg=" arg)) jvm-args))
         ;; tell jdtls the data directory and jvm args
         (contact (append '("jdtls") jvm-args `("-data" ,data-dir))))
    contact))

(push '((java-mode java-ts-mode) . jdtls-command-contact) eglot-server-programs)

How Eglot initialize JDTLS (User-specific configuration)

(defun jdtls-initialization-options ()
  (let ((setting-json-file (file-name-concat user-emacs-directory "lsp-config" "jdtls.json")))
    (with-temp-buffer
      (insert-file-contents setting-json-file)
      (json-parse-buffer :object-type 'plist :false-object :json-false))))

(cl-defmethod eglot-initialization-options (server &context (major-mode java-mode))
  (jdtls-initialization-options))

(cl-defmethod eglot-initialization-options (server &context (major-mode java-ts-mode))
  (jdtls-initialization-options))

jdtls.json example

{
  "settings": {
    "java": {
      "maxConcurrentBuilds": 1,
      "autobuild": {
        "enabled": false
      },
      "import": {
        "maven": {
          "enabled": true
        },
        "exclusions": [
          "**/node_modules/**",
          "**/.metadata/**",
          "**/archetype-resources/**",
          "**/META-INF/maven/**"
        ]
      },
      "configuration": {
        "updateBuildConfiguration": "automatic",
        "checkProjectSettingsExclusions": true,
        "runtimes": [
          {
            "name": "JavaSE-1.8",
            "path": "/usr/local/java-8"
          },
          {
            "name": "JavaSE-11",
            "path": "/usr/local/java-11"
          },
          {
            "name": "JavaSE-17",
            "path": "/usr/local/java-17"
          },
          {
            "name": "JavaSE-19",
            "path": "/usr/local/java-19",
            "default": true
          }
        ]
      },
      "project": {
        "importHint": true,
        "importOnFirstTimeStartup": "automatic",
        "referencedLibraries": [
          "lib/**"
        ],
        "resourceFilters": [
          "node_modules",
          "\\.git",
          ".metadata",
          "archetype-resources",
          "META-INF/maven"
        ]
      },
      "server": {
        "launchMode": "Hybrid"
      },
      "format": {
        "settings": {
          "url": "/home/zsxh/.emacs.d/cache/eclipse-java-google-style.xml",
          "profile": "GoogleStyle"
        }
      },
      "contentProvider": {
        "preferred": "fernflower"
      },
      "completion": {
        "guessMethodArguments": true,
        "overwrite": true,
        "enabled": true,
        "favoriteStaticMembers": [
          "org.junit.Assert.*",
          "org.junit.Assume.*",
          "org.junit.jupiter.api.Assertions.*",
          "org.junit.jupiter.api.Assumptions.*",
          "org.junit.jupiter.api.DynamicContainer.*",
          "org.junit.jupiter.api.DynamicTest.*",
          "org.mockito.Mockito.*",
          "org.mockito.ArgumentMatchers.*",
          "org.mockito.Answers.*"
        ]
      }
    }
  },
  "extendedClientCapabilities": {
    "classFileContentsSupport": true,
    "overrideMethodsPromptSupport": true
  },
  "bundles": [
    "/home/zsxh/.emacs.d/cache/lsp-servers/java/bundles/dg.jdt.ls.decompiler.cfr-0.0.3.jar",
    "/home/zsxh/.emacs.d/cache/lsp-servers/java/bundles/dg.jdt.ls.decompiler.common-0.0.3.jar",
    "/home/zsxh/.emacs.d/cache/lsp-servers/java/bundles/dg.jdt.ls.decompiler.fernflower-0.0.3.jar",
    "/home/zsxh/.emacs.d/cache/lsp-servers/java/bundles/dg.jdt.ls.decompiler.procyon-0.0.3.jar"
  ]
}

You gonna download the bundles, formatter from vscode plugins yourself

How Eglot handle jdt:// scheme uri

(defvar eglot-path-uri-cache (make-hash-table :test #'equal)
  "File path to uri cache.")

(cl-defgeneric +eglot/ext-uri-to-path (uri)
  "Support extension uri."
  nil)

(define-advice eglot--uri-to-path (:around (orig-fn uri) advice)
  "Support non standard LSP uri scheme."
  (when (keywordp uri) (setq uri (substring (symbol-name uri) 1)))
  (or (+eglot/ext-uri-to-path uri)
      (funcall orig-fn uri)))

(define-advice eglot--path-to-uri (:around (orig-fn path) advice)
  "Support non standard LSP uri scheme."
  (or (gethash path eglot-path-uri-cache)
      (funcall orig-fn path)))

(defun +eglot/jdtls-uri-to-path (uri)
  "Support Eclipse jdtls `jdt://' uri scheme."
  (when-let* ((jdt-scheme-p (string-prefix-p "jdt://" uri))
              (filename (when (string-match "^jdt://contents/\\(.*?\\)/\\(.*\\)\.class\\?" uri)
                          (format "%s.java" (replace-regexp-in-string "/" "." (match-string 2 uri) t t))))
              (source-dir (file-name-concat (project-root (eglot--current-project)) ".eglot"))
              (source-file (expand-file-name (file-name-concat source-dir filename))))
    (unless (file-directory-p source-dir)
      (make-directory source-dir t))
    (unless (file-readable-p source-file)
      (let ((content (jsonrpc-request (eglot--current-server-or-lose)
                                      :java/classFileContents
                                      (list :uri uri))))
        (with-temp-file source-file (insert content))))
    (puthash source-file uri eglot-path-uri-cache)
    source-file))

(cl-defmethod +eglot/ext-uri-to-path (uri &context (major-mode java-mode))
  (+eglot/jdtls-uri-to-path uri))

(cl-defmethod +eglot/ext-uri-to-path (uri &context (major-mode java-ts-mode))
  (+eglot/jdtls-uri-to-path uri))

How Eglot handle (some) non standard LSP commands

;; https://github.com/joaotavora/eglot/discussions/888#discussioncomment-2386710
(cl-defmethod eglot-execute-command
  (_server (_cmd (eql java.apply.workspaceEdit)) arguments)
  "Command `java.apply.workspaceEdit' handler."
  (mapc #'eglot--apply-workspace-edit arguments))

(cl-defmethod eglot-execute-command
  (_server (_cmd (eql java.action.overrideMethodsPrompt)) arguments)
  "Command `java.action.overrideMethodsPrompt' handler."
  (let* ((argument (aref arguments 0))
         (list-methods-result (jsonrpc-request (eglot--current-server-or-lose)
                                               :java/listOverridableMethods
                                               argument))
         (methods (plist-get list-methods-result :methods))
         (menu-items (mapcar (lambda (method)
                               (let* ((name (plist-get method :name))
                                      (parameters (plist-get method :parameters))
                                      (class (plist-get method :declaringClass)))
                                 (cons (format "%s(%s) class: %s" name (string-join parameters ", ") class) method)))
                             methods))
         (selected-methods (cl-map 'vector
                                   (lambda (choice) (alist-get choice menu-items nil nil 'equal))
                                   (delete-dups
                                    (completing-read-multiple "overridable methods: " menu-items))))
         (add-methods-result (jsonrpc-request (eglot--current-server-or-lose)
                                              :java/addOverridableMethods
                                              (list :overridableMethods selected-methods :context argument))))
    (eglot--apply-workspace-edit add-methods-result)))

[joaotavora]

FTR, I do not recommend doing any of this at least until the problem is understood. The jtdls script should be good to startup Eglot in a such a simple environment as @rpaufin described.

[zsxh]

Thanks, .git directory worked for me. I didn't know that jdtls script can work out of the box for simple environment 🤣 . Last time I tried still tons of configurations.

[joaotavora]

No problem. The jdtls script was aded to the Eclipse JDT server with some help on our part. See #868.

Your code is probably still valid, but I'd say a large part of it is not necessary.

[huangfeiyu]

@zsxh I tried your "How Eglot initialize JDTLS (User-specific configuration)", but I can't get "java.autobuild.enabled=false" work nor "java.completion.importOrder=["java", "javax", "jakarta", "org", "co", "com", "io", "net", "software"]", however "java.configuration.runtimes" does work. "bundles" works too.
Will you suggest me please?
Here's my json file

{
  "settings": {
    "java": {
      "autobuild": {
        "enabled": false
      },
      "configuration": {
        "runtimes": [
          {
            "name": "JavaSE-11",
            "path": "/usr/local/jdk-11.0.21+9",
            "default": true
          },
          {
            "name": "JavaSE-17",
            "path": "/usr/lib/jvm/java-17-openjdk-amd64"
          }
        ]
      },
      "format": {
        "settings": {
          "url": "/home/huang/.emacs.d/lsp-config/eclipse-java-google-style.xml",
          "profile": "GoogleStyle"
        }
      },
      "completion": {
        "importOrder" : ["java", "javax", "jakarta", "org", "co", "com", "io", "net", "software"]
      }
    }
  },
  "extendedClientCapabilities": {
    "classFileContentsSupport": true,
    "overrideMethodsPromptSupport": true
  },
  "bundles": [
    "/home/huang/jdtls/com.microsoft.java.debug.plugin-0.51.1.jar"
  ]
}