Features

Below you can find all available features that clojure-lsp provides with examples using Emacs lsp-mode as the client.

• Built in LSP features
• clojure-lsp extra commands

LSP features

Find a function/var definition

Find defprotocol/defmulti implementations

Find a function/var declaration in the ns

Find all references of a function, var, keyword or namespace alias

Show all workspace/project symbols

Show all symbols on current file

Rename symbols

Also, it's possible to live rename symbols on the same buffer with linkedEditingRange feature.

Document highlight on hover showing symbol usages

Documentation and clojuredocs integration

Java support

To understand what is supported and how to configure it, check the settings section.

Completion

Snippets

Snippets are templates that make it easier to enter repeating code patterns, such as common functions/forms, they are available during completion. Tabstops are defined as $number with $0 as last tabstop.

Check all available snippets here

name	description	raw content
comment	Insert comment block	(comment\n ${0:body}\n )
comment-heading	Insert comment Header	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;; ${1:Namespace summary title}\n;;\n;; ${2:Brief description}\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n$0
comment-separator	Insert comment separator	;; ${1:Namespace summary title}\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n$0
rich-comment	Insert rich comment	(comment $0 #_())
rich-comment-rdd	Insert rich comment rdd block	#_{:clj-kondo/ignore [:redefined-var]}\n(comment\n $0 #_())
rich-comment-hotload	Insert rich comment library hotload	#_{:clj-kondo/ignore [:redefined-var]}\n(comment\n ;; Add-lib library for hot-loading\n (require '[clojure.tools.deps.alpha.repl :refer [add-libs]])\n (add-libs '{${1:domain/library-name} {:mvn/version \"${2:1.0.0}\"}$3})\n $0\n)
condp	Insert condp	(condp ${1:pred} ${2:expr}\n $0)
def	Insert def	(def ${1:name} $0)
def-	Insert def private	(def ^:private ${1:name} $0)
def-doc	Insert def with docstring	(def ${1:name}\n \"${2:docstring}\"\n $0)
defmethod	Insert defmethod	(defmethod ${1:name} ${2:match}\n [${3:args}]\n $0)
defmulti	Insert defmulti	(defmulti ${1:name} ${2:dispatch-fn})
defn	Insert public defn	(defn ${1:name} [$2]\n $0)
defn-doc	Insert public defn with docstring	(defn ${1:name}\n \"${2:docstring}\"\n [${3:args}]\n $0)
defn-	Insert private defn	(defn%s ${1:name} [$2]\n $0)
defprotocol	Insert defprotocol	(defprotocol ${1:Name}\n $0)
defrecord	Insert defrecord	(defrecord ${1:Name} [${2:fields}]\n ${3:Protocol}\n $0)
deftype	Insert deftype	(deftype ${1:Name} [${2:fields}]\n ${3:Protocol}\n $0)
fn	Insert fn	(fn [${1:arg-list}] $0)
for	Insert for	(for [${1:item} ${2:coll}]\n $0)
if	Insert if	(if ${1:test-expr}\n ${2:then-expr}\n ${3:else-expr})
kwargs	Insert keyword args	{:keys [${1:keys}] :or {${2:defaults}}}
let	Insert let	(let [$0])
letfn	Insert letfn	(letfn [(${1:name} [${2:args}]\n $0)])
ns	Insert ns	(ns ${1:name}\n $0:references})
ns-doc	Insert ns with docstring	(ns ${1:name}\n \"${2:docstring}\"\n ${0:references})
require	Insert ns :require	(:require [${1:namespace}])$0
require-as	Insert ns require with :as alias	(:require [${1:namespace} :as ${2:alias}]$3)
require-refer	Insert ns :require with :refer	(:require [${1:namespace} :refer [$2]]$3)
require-rdd	Insert require for rich comment experiments	(require '[${1:namespace} :as ${2:alias}]$3)$0
req-as	Insert single require dep :as alias	[${1:namespace} :as ${2:alias}]
req-refer	Insert single require dep with :refer	[${1:namespace} :refer [$2]]
import	Insert import	(:import [${1:package}])
use	Insert require refer preferred over use	(:require [${1:namespace} :refer [$2]])
deps-alias	Insert alias with extra path & deps	:${1:category/name}\n {:extra-paths [\"${2:path}\"]\n :extra-deps {${3:deps-maven or deps-git}}}$0
deps-maven	Insert maven dependency	${1:domain/library-name} {:mvn/version \"${2:1.0.0}\"}$0
deps-git	Insert git dependency	${1:domain/library-name}\n {:git/sha \"${2:git-sha-value}\"}$0
deps-git-tag	Insert git tag dependency	${1:domain/library-name}\n {:git/tag \"${2:git-tag-value}\"\n :git/sha \"${3:git-sha-value}\"}$0
deps-git-url	Insert git URL dependency	${1:domain/library-name}\n {:git/url \"https://github.com/$1\"\n :git/sha \"${2:git-sha-value}\"}$0
deps-local	Insert local dependency	${1:domain/library-name} {:local/root \"${2:/path/to/project/root}\"}$0
deftest	Insert deftest clojure.test	(deftest ${1:name}-test\n (testing \"${2:Context of the test assertions}\"\n (is (= ${3:assertion-values}))$4)) $0
testing	Insert testing clojure.test	(testing \"${1:Context of the test assertions}\"\n $0)
is	Insert is clojure.test	(is (= ${1:assertion-values}))

Custom snippets

User can register additional custom snippets. For more information, check the snippets config documentation.

Code actions

See below for screenshots.

Code lenses showing symbol references

Format a whole file or range

Signature help

Semantic tokens

The LSP server is the best to say what is the semantic value of a token on the editor, semantic tokens allows server return to client all tokens of a buffer and how client show apply highlight.

Note: server return the semantic token (e.g. function) and the client/editor apply the color that matches the user's theme.

Call hierarchy

Show the incoming or outgoing call hierarchy of a function/variable as a lazy tree

Incoming

Show functions that call the current one recursively

Outgoing

Show functions that the current one call, recursively

Test Tree

Show the tests tree hierarchy of a file

Project tree

Show the project tree ns and external dependencies.

Diagnostics (linter)

All linters besides the ones below come from clj-kondo that clojure-lsp calls under the hood to lint the code and retrieve the analysis to make most of features work.

Every linter configuration should be done on clj-kondo side, so anything related to unresolved symbols or unknown macros are probably related to wrong clj-kondo for the project. For more information on how to configure clj-kondo check here.

Below you can find the custom linters implemented on clojure-lsp side that uses the :custom-lint-fn from clj-kondo:

clojure-lsp/unused-public-var

For more information on how to configure it, check the diagnostics settings section.

clj-depend

Clojure-lsp has a optional integration with clj-depend, making it easier to configure namespaces relationship.

For more information on how to configure it, check the diagnostics settings section.

Stub generation

It's possible to configure clojure-lsp to generate and analyze stubs for specific namespaces available on your project classpath, this is useful for closed source dependencies like datomic.api, with that clojure-lsp will be able to make most features work with those dependencies. For more information check the stubs settings section.

Execute command

Commands that client can request. Most code actions use these commands as actions.

clojure-lsp extra commands

Note: Most of these are available via code actions and clients or users may choose to use the code action menu to execute them instead of mapping.

All functions in clojure-lsp have a two-letter mnemonic shortcut. E.g. tf for thread-first-all. We strongly suggest that client authors and users use these shortcuts keys when choosing to map these commands to key chords or menus; this allows for users to maintain muscle memory and familiarity as they switch between clients and editors. Thank you to clj-refactor for this system and other tools that adhere to it.

LSP clients will allow you to bind these commands to shortcuts or menu items using LSP's workspace/executeCommand and passing a map with "command" and "arguments" keys.

Arguments:

• file-uri: Absolute file uri. e.x. file:///home/user/project/src/main.clj
• row: line-number of the cursor, 0 based.
• col: col-number of the cursor, 0 based.
• name: Used when introducing a name, usually a string for a valid clojure symbol.
• filename: Filename path. e.x. src/utils.clj

Shortcut	Command	Name	Arguments	Available via code action	Example
ab	drag-param-backward	Drag param backward	[file-uri,row,col]	✅
af	drag-param-forward	Drag param forward	[file-uri,row,col]	✅
ai	add-missing-import	Add import to namespace	[file-uri,row,col[,name]]	✅
am	add-missing-libspec	Add missing require	[file-uri,row,col]	✅
as	add-require-suggestion	Add require suggestion	[file-uri,row,col,ns,alias,refer]	✅
cc	cycle-coll	Cycle collection (#{}, {}, [], ())	[file-uri,row,col]	✅
ck	cycle-keyword-auto-resolve	Cycle keyword auto-resolve	[file-uri,row,col]	✅
cn	clean-ns	Clean namespace	[file-uri,row,col]	✅
cp	cycle-privacy	Cycle privacy of def/defn	[file-uri,row,col]	✅
ct	create-test	Create test	[file-uri,row,col]	✅
df	demote-fn	Demote fn to #()	[file-uri,row,col]	✅
db	drag-backward	Drag backward	[file-uri,row,col]	✅
df	drag-forward	Drag forward	[file-uri,row,col]	✅
dk	destructure-keys	Destructure keys	[file-uri,row,col]	✅
ed	extract-to-def	Extract to def	[file-uri,row,col,name]	✅
ef	extract-function	Extract function	[file-uri,row,col,name]	✅
el	expand-let	Expand let	[file-uri,row,col]
fe	create-function	Create function from example	[file-uri,row,col]	✅
ga	get-in-all	Move all expressions to get/get-in	[file-uri,row,col]	✅
gl	get-in-less	Remove one element from get/get-in	[file-uri,row,col]	✅
gm	get-in-more	Move another expression to get/get-in	[file-uri,row,col]	✅
gn	get-in-none	Unwind whole get/get-in	[file-uri,row,col]	✅
il	introduce-let	Introduce let	[file-uri,row,col,name]
is	inline-symbol	Inline Symbol	[file-uri,row,col]	✅
ma	resolve-macro-as	Resolve macro as	[file-uri,row,col]	✅
mf	move-form	Move form	[file-uri,row,col,filename]	✅
ml	move-to-let	Move expression to let	[file-uri,row,col,name]	✅
pf	promote-fn	Promote #() to fn, or fn to defn	[file-uri,row,col,fn-name]	✅
rr	replace-refer-all-with-refer	Replace ':refer :all' with ':refer [...]'	[file-uri,row,col,refers]	✅
ra	replace-refer-all-with-alias	Replace ':refer :all' with alias	[file-uri,row,col]	✅
rk	restructure-keys	Restructure keys	[file-uri,row,col]	✅
sc	change-coll	Switch collection to {}, (), #{}, []	[file-uri,row,col,"map"/"list"/"set"/"vector"]	✅
sl	sort-clauses	Sort map/vector/list/set/clauses	[file-uri,row,col]	✅
tf	thread-first-all	Thread first all	[file-uri,row,col]	✅
th	thread-first	Thread first expression	[file-uri,row,col]
tl	thread-last-all	Thread last all	[file-uri,row,col]	✅
tt	thread-last	Thread last expression	[file-uri,row,col]
ua	unwind-all	Unwind whole thread	[file-uri,row,col]	✅
uw	unwind-thread	Unwind thread once	[file-uri,row,col]
fs	forward-slurp	Paredit: forward slurp	[file-uri,row,col]
fb	forward-barf	Paredit: forward barf	[file-uri,row,col]
bs	backward-slurp	Paredit: backward slurp	[file-uri,row,col]
bb	backward-barf	Paredit: backward barf	[file-uri,row,col]
rs	raise-sexp	Paredit: Raise sexp	[file-uri,row,col]
ks	kill-sexp	Paredit: Kill sexp	[file-uri,row,col]

Dev

Server information

Return basic information about the server.

Cursor information

Return debug information about the element at point.