v2026.07.24

Compare Source

Highlights

Type checking

The type checker now infers much more and respects required :keys! in Clojure 1.13 alphas.

It derives argument types from how a param is used in the body:

(defn f [s] (subs s 1))
(f 42)
   ^ Expected: string, received: positive integer.

It types the keys and values of destructured maps:

(defn f [{:keys [x]}] (inc x))
(f {:x "foo"})
       ^ Expected: number, received: string.

It flows map types from return values into destructured bindings:

(defn cfg [] {:port "8080"})
(let [{:keys [port]} (cfg)] (inc port))
                                 ^ Expected: number, received: string.

It flags keys that are provably nil:

(inc (:y {}))
     ^ Expected: number, received: nil.

It narrows a local's type when guarded by a known predicate:

(defn f [x] (if (string? x) (inc x) x))
                                 ^ Expected: number, received: string.

Clojure 1.13: built-in analysis is bumped to 1.13.0-alpha4 and the new map destructuring features are supported: required keys via :keys!, :syms! and :strs!, :select and :defaults. Required keys are checked at call sites:

(defn f [{:keys! [x]}] x)
(f {})
   ^ Missing required key: :x

Constant condition

The linter :constant-condition, which is :warning by default, warns on a condition whose truthiness is the same on every run:

(when inc :hello)
      ^ Condition always true

It replaces :condition-always-true, which was off by default.
Combined with the improved type inference, this can now find many more issues. In regression tests I've found multiple cases of filter and remove results being used as conditions, which are always true since they always return a seq.

Performance

Performance: linting is faster and allocates less. Var usages and bindings are now records, several rewrite-clj internals were optimized (@​alexander-yakushev) and hot analyzer functions were split so they can be JIT-compiled.

All updates

• Vars defined in comment forms no longer count for :shadowed-var, :unused-private-var and :inline-def. E.g. (defn f [bar] bar) after (comment (def bar 1)) no longer warns. Defs in comment forms also no longer overwrite the arity and position of defs outside of them.
• Macros from source: expand-time resolve of a symbol qualified with the source namespace finds the extracted var, and the :clj-kondo/macroexpand-hook marker now works on declare.
• Performance: split hot analyzer and linter functions so they stay under the JIT compilation size limit (#​2907, #​2908, #​2909, #​2910, #​2911)
• #​721: NEW linter: :constant-condition: warn on a condition whose truthiness is the same on every run. On by default. Replaces :condition-always-true, whose config and ignores still apply to always-true conditions, and takes over the cond catch-all warning from :unreachable-code, which now only covers reader conditional branch order. See docs.
• #​2900: :discouraged-var: new per-var :positions option (a set or vector of :call and/or :value) to limit the warning to call position or value position. A var passed to a higher-order function such as map counts as :value.
• #​1882: built-in support for clojure.test.check.clojure-test/defspec
• #​2851: NEW linter: :seq-rest: suggest using (next x) over (seq (rest x)). Defaults to :off (@​tomdl89)
• #​2877: warn when #_ before an unmatched reader conditional discards the next form. E.g. [#_#?(:cljs 1) 2] reads as [] in :clj and will warn.
• #​2888: fix false positive :redundant-fn-wrapper for keyword functions in specs (@​jramosg)
• #​2869 Replace type-mismatch arities instead of merging
• Type checker: infer and and or return types. E.g. (when (or x :default) ...) will warn.
• Type checker: the return types of re-matches and re-find are nilable.
• Type checker: the return type of class is nilable, (class nil) returns nil.
• Type checker: an if without an else branch includes nil in its return type.
• The minimum Clojure version to run clj-kondo on the JVM is now 1.11.
• Performance: use a record for bindings (~4%)
• Type checker: infer the value type of a destructured map key from how it is used in the body. E.g. (defn f [{:keys [x]}] (inc x)) (f {:x "foo"}) will warn. A key whose use rejects nil and that has no :or default is required. E.g. (f {}) will warn with missing required key.
• Type checker: a destructured binding gets the value type of its key when the map's type is known, including through function return maps. E.g. (defn cfg [] {:port "8080"}) (let [{:keys [port]} (cfg)] (inc port)) will warn.
• Type checker: a key missing from a map literal is provably nil, also through destructuring, keyword access chains and function return maps. E.g. (inc (:y {})) will warn. A key with an :or default, generated maps in macro expansions, maps with dynamic keys, and maps that went through into or an assoc with a dynamic key are exempt.
• Built-in analysis now uses Clojure 1.13.0-alpha4. Param type inference over the core sources grows the arg type coverage of clojure.core from 23 to 150 vars. E.g. (interleave 1 [2]) and (mod "a" 2) will warn.
• Type checker: contains? accepts nil as its collection argument
• Type checker: infer the type of a function param from how it is used in the body. E.g. (defn f [s] (subs s 1)) (f 42) will warn, since the evidence (subs s 1) tells us that s should be a string.
• Add types for parse-long, parse-double, parse-uuid and parse-boolean
• Type checker: narrow the type of a local in the then-branch of if or the body of when when it is guarded by a known predicate. E.g. (if (string? x) (inc x) ...) will warn.
• Clojure 1.13 CLJ-2961: map destructuring :keys! :syms! :strs! with required keys
• Clojure 1.13 CLJ-2961: report a binding symbol after &, or a second &, in a map destructuring keys vector as a syntax error
• Clojure 1.13 CLJ-2954: & is now invalid as a binding name in all binding positions
• Clojure 1.13 CLJ-2961: error for :or default on :keys! required binding, matches 1.13 compile error
• Clojure 1.13 CLJ-2961: infer required keys from :keys!, :syms! and :strs! and report them at call sites
• #​2874: Clojure 1.13 CLJ-2964: support :select in map destructuring. The bound map's keys are known to the type checker
• Clojure 1.13 CLJ-2966: support :defaults in map destructuring, error when used without :or
• #​2849: :conflicting-alias now catches conflicts with the current namespace name, not just other aliases (@​tomdl89)
• #​2848: allow calling sets and vectors with 2 arguments in ClojureScript, where the second argument is the not-found value (@​p-himik)
• #​2854: fix false positive :invalid-arity when an inner binding or fn param shadows a local function name (@​yuhan0)
• Performance optimizations: #​2853, #​2857, #​2858, #​2859, #​2862, #​2866 (@​alexander-yakushev)
• #​2864: --copy-configs no longer rewrites and reports unchanged config files on every run (@​nikbad)
• Performance: use a record for var usages: -13.5% allocation, ~5-10% faster linting
• Bump SCI to 0.15.56