Skip to content


Above you can find all available features that clojure-lsp provide with examples using Emacs lsp-mode client.

Find a function/var definition#

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

Show all workspace/project symbols#

Show all symbols on current file#

Rename symbols#

Document highlight on hover showing symbol usages#

Documentation and clojuredocs integration#



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$ Create comment block (comment\n $0\n )
condp$ Create condp (condp ${1:pred} ${2:expr}\n $0)
def$ Create def (def ${1:name} $0)
defmethod$ Create defmethod (defmethod ${1:name} ${2:match}\n [${3:args}]\n $0)
defmulti$ Create defmulti (defmulti ${1:name} ${2:dispatch-fn})
defn-$ Create private function (defn%s ${1:name} [$2]\n $0)
defn$ Create public function (defn ${1:foo} [$2]\n $0)
defprotocol$ Create defprotocol (defprotocol ${1:Name}\n $0)
defrecord$ Create defrecord (defrecord ${1:Name} [${2:fields}]\n ${3:Protocol}\n $0)
deftype$ Create deftype (deftype ${1:Name} [${2:fields}]\n ${3:Protocol}\n $0)
fn$ Create fn (fn [${1:arg-list}] $0)
if$ Create if (if ${1:test-expr}\n ${2:then-expr}\n ${3:else-expr})
import$ Create import (:import [${1:package}])
kwargs$ Create keyword args {:keys [${1:keys}] :or {${2:defaults}}}
let$ Create let (let [$0])
letfn$ Create letfn (letfn [(${1:name} [${2:args}]\n $0)])
ns$ Create ns (ns $1\n $0)
require$ Create require (:require [${1:namespace} :as [$0]])
use$ Create use (:use [${1:namespace} :only [$0]])
Custom snippets#

User can register additional custom snippets, for more information on how to configure it, check the snippets settings section.

Code actions#

Name Example
Clean namespace require/imports
Add missing require
Add known common require
Add known common import
Add suggested alias require
Inline symbol
Extract function
Move to let
Change coll to map,vector,set,list
Thread first/all last
Create private function
Resolve macro as...

Code lenses showing symbol references#

Format a whole file or range#

Signature help#

Semantic tokens#

Experimental: apply color on client editor for each known token

Call hierarchy#

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


Show functions that call the current one recursively


Show functions that the current one call, recursively

Execute command#

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


Commands that change/refactor the code, most of them are available via code actions.

Clean namespace *#
Add import to namespace#
Add missing namespace *#
Cycle privacy of def/defn#
Cycle collection (#{}, {}, [], ())#
Change collection to {}, (), #{}, []#
Extract Function *#
Create private function *#
Inline Symbol *#
Expand let#
Introduce let#
Move expression to let#
Thread first expression#
Thread last expression#
Thread first all *#
Thread last all *#
Unwind all#
Unwind thread#
Create test#

Resolve macro as *#

This code action should be wrapped by the LSP client to provide the missing arguments beside the existing return by the code action:

  • The macro which should resolve as e.g. clojure.core/def
  • The clj-kondo configuration to save the new setting. e.g /home/user/.clj-kondo/config.edn

For an example, check how Emacs LSP client handles that.

* Available via code actions too


Server information#

Return basic information about the server.

Cursor information#

Return debug information about the element at point.

Custom message to client during any server process#

During some process, clojure-lsp send messages to client informing some proccess, warning or error.

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:


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

Last update: October 20, 2021