eclipse.jdt.ls VS nvim-lspconfig

Thanks Eclipse : https://github.com/eclipse-jdtls/eclipse.jdt.ls

I installed eclipse jdtls which worked for Java, but I was not able to go to definitions for methods/classes outside of my project (ie, libraries and such, something like in IntelliJ where you can go to the definition or implementation for the library code), so I thought it may be a limitation of nvim-lspconfig

return { { "neovim/nvim-lspconfig", dependencies = { "mfussenegger/nvim-jdtls", init = function() require("lazyvim.util").on_attach(function(_, buffer) -- stylua: ignore vim.keymap.set( "n", "di", "lua require'jdtls'.organize_imports()", { buffer = buffer, desc = "Organize Imports" } ) vim.keymap.set( "n", "dt", "lua require'jdtls'.test_class()", { buffer = buffer, desc = "Test Class" } ) vim.keymap.set( "n", "dn", "lua require'jdtls'.test_nearest_method()", { buffer = buffer, desc = "Test Nearest Method" } ) vim.keymap.set( "v", "de", "lua require('jdtls').extract_variable(true)", { buffer = buffer, desc = "Extract Variable" } ) vim.keymap.set( "n", "de", "lua require('jdtls').extract_variable()", { buffer = buffer, desc = "Extract Variable" } ) vim.keymap.set( "v", "dm", "lua require('jdtls').extract_method(true)", { buffer = buffer, desc = "Extract Method" } ) vim.keymap.set( "n", "cf", "lua vim.lsp.buf.formatting()", { buffer = buffer, desc = "Format" } ) end) end, }, ---@class PluginLspOpts opts = { ---@type lspconfig.options servers = {}, -- you can do any additional lsp server setup here -- return true if you don't want this server to be setup with lspconfig ---@type table setup = { -- example to setup with typescript.nvim jdtls = function(_, opts) local project_name = vim.fn.fnamemodify(vim.fn.getcwd(), ":p:h:t") -- vim.lsp.set_log_level('DEBUG') local workspace_dir = "/home/jake/.workspace/" .. project_name -- See `:help vim.lsp.start_client` for an overview of the supported `config` options. local config = { -- The command that starts the language server -- See: https://github.com/eclipse/eclipse.jdt.ls#running-from-the-command-line cmd = { "java", -- or '/path/to/java17_or_newer/bin/java' "-javaagent:/home/jake/.local/share/java/lombok.jar", -- '-Xbootclasspath/a:/home/jake/.local/share/java/lombok.jar', "-Declipse.application=org.eclipse.jdt.ls.core.id1", "-Dosgi.bundles.defaultStartLevel=4", "-Declipse.product=org.eclipse.jdt.ls.core.product", "-Dlog.protocol=true", "-Dlog.level=ALL", -- '-noverify', "-Xms1g", "--add-modules=ALL-SYSTEM", "--add-opens", "java.base/java.util=ALL-UNNAMED", "--add-opens", "java.base/java.lang=ALL-UNNAMED", "-jar", vim.fn.glob("/usr/share/java/jdtls/plugins/org.eclipse.equinox.launcher_*.jar"), "-configuration", "/usr/share/java/jdtls/config_linux", "-data", workspace_dir, }, root_dir = require("jdtls.setup").find_root({ ".git", "mvnw", "gradlew" settings = { java = {}, }, } require("jdtls").start_or_attach(config) return true end, -- Specify * to use this function as a fallback for any server -- ["*"] = function(server, opts) end, }, }, }, }

You can absolutely just use Gradle on the command line, and use a language server to get code intelligence in pretty much any editor you like. IntelliJ is very nice, especially for refactoring, but it doesn't have a giant advantage over any other editor, as long as you're sticking to mostly Java.

Try neovim. Builtin support for language servers which provide the basis for IDE functionality, autocomplete, auto import, code actions, refactoring, etc. I believe VSCode uses jdtls on the backend and you can use the same thing with neovim.

Is seems like valid manual to start language server here https://github.com/eclipse/eclipse.jdt.ls. Not sure what you mean by "starting it with other editors" though. It should be covered by editor own integration with the given LS.

But all of the above to say that Emacs can have the ability to some of if not more than VSCode. As others have said, the Jetbrains IDEs are a different story. They're built to actually understand the code you're writing. It's quite possible, with features like auto-insert and skeletons, to replicate some of the functionality that, say, IntelliJ does. For example, say you find-file into a new file for some Java project. When you first enter the buffer, you could setup a prompt to create a class, enum, interface etc. and then upon a selection, you have the basic relevant code for whatever the selection was made auto-inserted. Or you could just quit the prompt with C-g. Granted that takes some time to set up as well as recreating other smaller features that IntelliJ has. JDTLS can do some of this, but at the end of the day it's not a replacement for IntelliJ and I don't think JDTLS intends to be such.

Just the other day I tested VS Code Java again and apparently the Red Hat team that did the Java language support has gotten some level of null analysis turned on now. Thus I assume the Eclipse LSP https://github.com/eclipse/eclipse.jdt.ls has that support now.

I suggest looking for blog posts about this, you're gunnuh wanna pick out a plugin manager and stuff. It's kind of like a package manager for neovim. You can install everything manually but usually you manually install a plugin manager and it gives you commands to manage the rest of your plugins.

These two plugins are the bare minimum in my view.

https://github.com/nvim-treesitter/nvim-treesitter

Treesitter gives you much better syntax highlighting based on a parser for a given language.

https://github.com/neovim/nvim-lspconfig

This plugin helps you connect to a given language LSP quickly with sensible defaults. You more or less pick your language from here and copy paste a snippet, and then install the relevant LSP:

https://github.com/neovim/nvim-lspconfig/blob/master/doc/ser...

For Python you'll want pylsp. For JavaScript it will depend on what frontend framework you're using, I probably can't help you there.

pylsp itself takes some plugins and you'll probably want them. https://github.com/python-lsp/python-lsp-server

Best of luck! Happy hacking.

Adding language support it neovim isn't very difficult once you're setup. I use nvim-lspconfig[1] and just about any language you could need is documented[2]. But like others have mentioned there are batteries included distributions of neovim if that's your cup of tea.

[1]: https://github.com/neovim/nvim-lspconfig/

[2]: https://github.com/neovim/nvim-lspconfig/blob/master/doc/ser...

If we can't find the basic usage in the documentation we can go to nvim-lspconfig's github repository. In there we look for a folder called server_configurations, this contains configuration files for a bunch of language servers.

https://github.com/hrsh7th/nvim-cmp This is an autocompletion engine https://github.com/nvim-treesitter/nvim-treesitter This allows NeoVim to install parsing scripts so NeoVim can do things like code highlighting. https://github.com/williamboman/mason.nvim Not strictly necessary, but allows you to access a repo of LSP, install them, and configure them for without you actively messing about in config files. https://github.com/neovim/nvim-lspconfig Also not strictly necessary, but vastly simplifies LSP setup. https://github.com/williamboman/mason-lspconfig.nvim This lets the above two plugins talk to each other more easily.

This specific issue talks about fixing clangd for that error: https://github.com/neovim/nvim-lspconfig/issues/2184. The issue is ongoing for ccls AFAIK but for clangd, this has been discussed and fixed in the past already.

I am trying to set up the pbkit language server for protobuf files. Since it is not part of the nvim-lspconfig repo's server configurations, I have to figure the way out myself. It doesn't seem to be too difficult, as I can start from the bufls configuration there. The following is what I have at the moment:

I have configured neovim with lspconfig and mason. Added the suggested configuration of the lsp config(https://github.com/neovim/nvim-lspconfig) to ~/.config/nvim/after/plugin/lsp.lua Then I installed via mason the following language servers:

Personally, i think nvim-lint is the best alternative currently, specially so because it has no dependencies on external binaries. This guide assumes you already have your LSP set up with nvim-lspconfig (or an alternative like lsp-zero). You should also have an way to install the linters you are gonna need, i highly recommend Mason with mason-lspconfig.

Basically neovim can act as a client to a variety of different language servers (https://github.com/neovim/nvim-lspconfig/blob/master/doc/ser...) which give neovim IDE capabilities. This can be done in original Vim also but requires external plugins which can be a pain to compile and install. Neovim has it built in.

I'm struggling to get [sqlls](https://github.com/joe-re/sql-language-server) with [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig) to use Postgres syntax.