Features

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

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

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$	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 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

Incoming

Show functions that call the current one recursively

Outgoing

Show functions that the current one call, recursively

Execute command

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

Refactoring

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

Clean namespace *

Add import to namespace

Add missing require *

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

Dev

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:

clojure-lsp/unused-public-var

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