Open Source Contributions

Introduced a new linter `:if-x-x-y` that suggests replacing `(if x x y)` with `(or x y)` when the condition is a simple symbol. Disabled by default; ships with documentation, configuration entry, and tests covering the pattern as well as false-positive guards. Resolves #2062.

Introduced a new linter :unimplemented-protocol-method-arity that warns when a protocol or interface method is implemented with an arity that does not match any declared in the protocol. Extended detection to definterface method implementations as well.

Added a new linter :not-nil? that suggests using `(some? x)` instead of `(not (nil? x))` for clearer, more idiomatic Clojure. Includes ClojureScript support, configurable level, ignore handling, tests, and documentation.

Introduced a new linter :redundant-declare that warns when declare is used after a var is already defined in the same namespace. Updated documentation and configuration to include this new linter with comprehensive tests to ensure correct functionality and behavior.

Implemented a new linter :aliased-referred-var that warns when a var is both referred and accessed via an alias in the same namespace.

Created a linter :is-message-not-string that warns when clojure.test/is receives a non-string message argument.

Introduce a new linter `:duplicate-refer` that warns on duplicate entries in `:refer` vectors within `:require` statements. This change includes documentation updates and tests to ensure proper functionality of the new linter.

Introduce a new type `class` and enhance type checking for class-related functions including `instance?`, `cast`, `class`, `make-array`, `bases`, and `supers`. This improves type safety and error reporting for functions that require class arguments, ensuring better validation during linting.

Implemented a linter to warn on literals and constants used in clojure.test/is forms that always evaluate to true, preventing common testing mistakes.

Implemented a linter to warn when format strings are used without any format specifiers, indicating potential misuse of formatting functions.

Implemented a new linter to warn on unused vars in :refer-clojure :exclude, helping developers maintain cleaner code by identifying unnecessary exclusions.

Created a linter to warn on s-expressions in :or defaults in map destructuring, preventing common pitfalls where developers expect lazy evaluation but get eager evaluation.

Added comprehensive type checking support for array operations including to-array, alength, aget, aset, and aclone functions. Introduced new array type for better static analysis.

Built a linter to warn on non-existing vars in :refer-clojure :exclude, preventing typos and references to non-existent symbols.

Developed a linter to warn on ~ and ~@ usage outside syntax-quote (`), catching common macro-related mistakes early in development.

Fixed a false positive where `:refer-clojure :exclude` combined with a `:refer` `:rename` would incorrectly flag the excluded var as unused. The referred-vars map keys by the renamed name while `:name` keeps the original, so the excluded symbol never appeared in the used-vars set. Resolves #2813.

Refactored `analyze-defn` to extract a `method-arities-by-name` helper that accumulates all arities per method name and folds the definterface +1 (target object) adjustment inline with `cond->>`. The previous `(into {} meths)` silently dropped earlier entries when a `definterface` declared the same method name with different arities, so only the last arity survived for arity checks. Resolves #2814.

Fixed linter-specific ignore metadata (e.g., `#_{:clj-kondo/ignore [:invalid-arity]}`) to correctly respect the specified linters instead of suppressing all linters. Modified `utils/ignored?` to accept an optional linter parameter and updated call sites in `linters.clj` and `analyzer/namespace.clj` to pass linter types. Also extended linter-specific ignore support to inline metadata.

Added type support for pmap with proper arity checking, enforcing that pmap receives 2 or more arguments. Also refactored map and mapcat to use a shared type definition for consistency and maintainability in type handling.

Refactored the lint-cond-constants! function to remove expensive sexpr usage, improving performance in linting operations.

Resolved regression where primitive array class syntax (e.g., byte/1, int/2) was not recognized in type checking.

Updated the unreachable-code linter to warn when :default does not come last in reader conditionals.

Introduced a new type `inst` and enhanced type checking for `inst-ms` and `inst-ms*`. These changes ensure that these types are correctly handled in the linter, improving type safety and providing clearer error messages for type mismatches.

Added comprehensive type checking for clojure.test functions like is, testing, deftest, etc., enabling static analysis to catch type mismatches in test code.

Extended type checking support to sorted-map-by, sorted-set, and sorted-set-by functions, improving static analysis coverage for sorted collection operations.

Implemented analysis to report unresolved namespace for namespaced maps with unknown aliases, catching configuration errors in namespaced keyword usage.

Add comprehensive :ratio type support to clj-kondo's type system, enabling type checking for the numerator and denominator functions.

Introduced comprehensive type support for functions related to futures, including future, future-call, future-done?, future-cancel, and future-cancelled?. Added tests to ensure correct linting behavior for these types.

Removed an unnecessary `#_:clj-kondo/ignore` directive on the regex memoization helper. The discouraged-var warning it suppressed no longer applies, so the ignore was dead code.

Audited the optional-linters documentation and added the entries that were off-by-default but missing from the docs, so every optional linter is now discoverable from the configuration reference.

Replaced repeated `re-pattern` calls in `files-count` and `process-file` with a precomputed `path-separator-pat` regex constant, avoiding redundant pattern compilation on every classpath entry processed.

Fixed a false positive where throwing a string in ClojureScript would incorrectly trigger a type mismatch warning.

Ensured that def + defmethod combinations trigger :def-fn warnings with valid source locations.

Added location metadata to excluded vars in ns-unmap for the unused-excluded-var linter.

Fixed recognition of gensym bindings in nested syntax quotes for proper analysis.

Extended the :equals-expected-position linter to also warn for not= when the expected value is not first.

Fixed false positive warnings for throw in ClojureScript when throwing non-throwable values.

Improved handling of `:refer-clojure :exclude` to properly ignore elements with `#_clj-kondo/ignore` metadata.

Resolved a regression causing false positives for unused binding warnings in `~'~` unquote expressions.

Updated the unused value linter to allow unused values in `defmethod` bodies.

Renamed the linter from :refer-clojure-exclude-unresolved-var to :unresolved-excluded-var for consistency across the codebase. Updated references in documentation, configuration, and test files.

Fixed false positive :unexpected-recur warning when recur is used inside clojure.core.match/match expressions, improving accuracy of control flow analysis.

Added type definitions for repeatedly.

Introduced a new option :max-column-alignment-gap to limit the maximum number of spaces inserted between a key and its aligned value. This prevents excessive horizontal padding in maps that contain outlier keys while still allowing normal alignment for shorter keys.

Adds a new configuration option :blank-lines-separate-alignment? that allows column alignment to treat blank lines as group separators. When enabled, alignment groups are separated by blank lines, allowing independent alignment within each group rather than across the entire form. This refactors the column alignment logic to support both the original behavior (aligning across all lines) and the new grouped behavior.

Ignore .clj configuration files by default for security. Introduce the :read-clj-config-files? option to opt in to reading .clj config files. When a .clj config file is detected but the option is not enabled, emit a warning and fall back to .edn config files if available.

:normalize-newlines-at-file-end? ensures files end with exactly one newline character. When enabled, cljfmt removes multiple trailing blank lines and guarantees a single newline at EOF for consistent file endings.

Added support for indentation rules applied to vars introduced via :refer in namespace declarations. cljfmt now looks up the original module for referred vars and applies any configured indentation rules for the fully-qualified name.

Introduced :align-single-column-lines? configuration option to control column alignment behavior in maps and forms. This prevents excessive horizontal padding when forms contain multi-line values.

Fixed `:split-keypairs-over-multiple-lines?` to no longer insert a stray newline before the first key in a map. The `map-key-without-line-break?` predicate now also requires the key to have a left sibling, so the leading position is excluded from line-break insertion.

Added validation for symbol-keyed configuration maps (e.g. `:aligned-forms`, `:extra-blank-line-forms`) so malformed keys are reported with a clear error instead of silently producing wrong output. Resolves issue #405.

Cached the namespace name under a `::ns-name` opts key so `indent`, `align-form-columns`, and other passes reuse it instead of each re-running `find-namespace` over the same form. Both `indent` and `align-form-columns` now check the cached value first before falling back to discovery.

Optimized indent rule processing by compiling indent rules once per file instead of once per node, significantly reducing redundant computation during formatting.

Fixed the :sort-ns-references? option to perform case-insensitive string sorting, preventing uppercase namespace references from sorting before lowercase ones. Modified the node-sort-string function and added a test case.

Corrected README examples for `:aligned-forms` and `:extra-blank-line-forms` to use bare symbols (`{let #{0}}`, `{cond :all}`) instead of quoted symbols (`{'let #{0}}`), matching the format the configuration loader actually accepts.

Added a new configuration option calva.paredit.toggleCommentBehavior with multiple strategies for toggling comments. When text is selected or cursor is in a line comment, toggles line comments as before. When there is no selection, users can choose between: Toggle Ignore (#_) Current Form, Toggle Ignore (#_) Parent Form, or Toggle Comment (;;) Current Line (default). Implemented toggleIgnoreForm function that triggers when appropriate based on user configuration and cursor context. Updated documentation describing all available options.

Added a structural toggle comment command that inserts line comments while preserving paredit structure (parentheses and form integrity). Includes command/keybinding integration and integration tests for the new workflow.

Major migration of Calva's code formatting infrastructure to cljfmt 0.16.0. Updated cljfmt dependency from 0.13.1 to 0.16.0 and migrated formatter to use cljfmt's native alignment capabilities. Removed 4,600+ lines of legacy pez-cljfmt and pez-rewrite-clj code. Added comprehensive tests for align-associative conversion logic to ensure compatibility with new formatting behavior.

Fixed a race condition where pressing keys before indentation was applied would cause text to be garbled and cursor position to jump. Introduced calculateIndentEdit() function that returns TextEdit objects instead of performing edits directly, reducing timing conflicts. Increased debounce delay from 250ms to 400ms to give users more time between typing and formatting. Refactored FormatOnTypeEditProvider to use the new indent calculation method while maintaining backward compatibility with the old indent engine.

Introduced comprehensive configuration system for custom pair forms and threading macros, now configurable via VS Code Settings menu. Users can define custom pair forms and threading macros through the VS Code UI settings panel, JSON settings, or config.edn file. Implemented createPareditConfig function that merges custom and default configurations, enabling complete paredit customization.

Fixed slurp forward and backward operations to properly handle s-expressions with #_ (ignore marker) comments. Modified forwardSexp and backwardSexp in token-cursor.ts to treat #_(form) as a unified s-expression unit rather than separate tokens, preventing errors during slurp operations.

Enhanced grow selection and drag sexp to recognize test/result pairs and test/:>>/function triples within condp expressions. Properly handles default values (unpaired elements at the end).

Fixed the `extract-function` command to always append selection-end coordinates when invoked, since clojure-lsp destructures those args unconditionally. Without them, a 4-arg call would throw IndexOutOfBoundsException, breaking extract-function when no region was selected.

Updated the status bar to react to jack-in task execution and interruption events so a failed or cancelled jack-in no longer leaves the status bar stuck displaying "Launching REPL".

Updated the `dev.weavejester/cljfmt` dependency to 0.16.4 and fixed Calva's "Format and Align Current Form" command for map literals so alignment behaves correctly on top-level maps.

When the cursor sits at the end of `#_(form)`, evaluate-selection now strips the leading `#_` and sends only `(form)` to the REPL instead of the silently-discarded discard form.

Hoisted `vscode.workspace.getConfiguration` for comment-form config out of the per-token highlight loop, reading it once before iterating visible ranges instead of on every token. Resolves a multi-second hang on backward navigation and backspace in large files introduced in 2.0.564.

Added configuration support for custom comment forms, allowing users to define their own comment form patterns that Calva recognizes for structural editing. Resolves issue #3117.

Extended current form detection to correctly identify `#_` (discard) commented forms regardless of where the cursor is positioned within them. Previously cursor position within the commented form affected whether it was included in the current form selection.

Fixed toggle comment to apply built-in formatting after structurally inserting or removing comment markers, ensuring proper indentation is maintained across the affected form after toggling.

Fixed Ctrl+click (go to definition) code navigation that would fail after starting a REPL session. Resolved by correcting the initialization order and state used when resolving navigation targets.

Extended the toggleLineCommentCommand to accept arguments so separate keyboard shortcuts can be bound for different commenting styles. This allows users to customize behavior for line comments vs structural ignore commands and resolves issue #3100. Updated associated tests and documentation to reflect new parameters.

Additional fixes for multi-line toggle comment: prevents breaking code structure during comment insertion and handles the edge case where comments share the same column as subsequent code, preserving correct indentation after toggling.

Fixed toggle comment operation on multi-line selections to correctly add and remove line comment markers for each selected line, resolving cases where only the first or last line was affected.

Fixed the insertSemiColon function to perform all edits in a single document model transaction, enabling proper undo behavior. Previously, the semicolon insertion required multiple separate edits that could not be undone as a single operation. Now, inserting and undoing semicolons works seamlessly as an atomic operation.

Improved breakpoint instrumentation error reporting with richer context, fixed token cursor initialization, and corrected document symbol handling. Added debugging examples for projectless test data to validate the workflow.

Corrected deps.edn detection for projectless REPLs by fixing the cljCommandLine condition and removing a redundant stat call. Added integration test coverage in projectless fixtures.

Enhanced jack-in dependency version resolution to find and display the latest versions (both release and prerelease) instead of stopping at the first cached version. When a prerelease is found, the UI now displays both the latest stable release and prerelease version side by side, giving developers full visibility into available versions.

Fixed forward delete operation to delete the entire #_ (discard comment) token in a single keypress when cursor is positioned at the start of the token. Previously, forward delete would only remove the # character, requiring two deletions to fully remove the #_ token.

Fixed backspace operation to delete the entire #_ (discard comment) token in a single keypress when cursor is positioned immediately after the token. Previously, backspace would jump over the token instead of deleting it, treating it like structural delimiters.

Fixed jack-in dependency version resolution to always refresh from Clojars instead of returning early when dependencies were cached. Removed the early return when all dependencies were cached, ensuring users always see the latest available versions (e.g., nrepl 1.5.2 instead of stale 1.5.1).

Fixed issue where pressing Ctrl+Backspace inside line comments would prevent subsequent deletions from working correctly. Modified the backspace handler to avoid processing Ctrl+Backspace within line comment contexts.

Resolved issue where regular vectors in let body contexts were incorrectly treated as pair forms during grow selection and drag sexp operations. Enhanced vector detection logic to distinguish between binding vectors and regular vectors by directly comparing opening positions, ensuring accurate pair form behavior.

Enhanced pair selection and drag sexp operations to correctly recognize and handle test/expression pairs within cond-> and cond->> threading macros. Added comprehensive test coverage for nested threading macros (e.g., cond-> with assoc pairs) to ensure proper expansion behavior.

Added support for treating assoc form pairs in paredit operations (grow selection and drag sexp). The assoc form has the structure (assoc map key value key value ...) where key-value pairs start after the map argument (offset 2). This brings feature parity with other pair-aware forms like cond, case, and condp.

Enhanced pair-aware forms (flatPairForms) to work correctly inside -> threading macros. The fix reduces the offset by 1 when inside a threading context to maintain proper pair calculation without breaking existing functionality.

Unified the handling of pair forms (like let bindings, cond pairs, and keyword-based modifiers) within the Paredit logic. Introduced PairFormConfig supporting VectorBindingForm, KeywordPairForm, and FlatPairForm styles. Enhanced parent validation and generalized triple handling (like test :>> expression in condp). Replaced hardcoded bindingForms and conditionalForms arrays with defaultPairForms for improved extensibility.

Enhanced grow selection and drag sexp to handle value/result pairs in case forms, similar to existing support for cond and binding forms like let.

Enhanced grow selection and drag sexp to recognize :let binding pairs within for loops, doseq, and other binding forms. Updated logic to detect :let vectors and expand through binding pairs before selecting the entire vector.

Implemented pair selection and dragging functionality for cond forms, enabling users to select and move test/expression pairs within conditional forms. Introduced conditionalForms constant and dynamic offset calculation for maintainable architecture.

Extended pair selection and dragging functionality to cond-> and cond->> threading forms, allowing intelligent selection and movement of test/expr pairs in threaded conditionals.

Switched `testNameSearchPattern` from backslash-escaped regex special characters to character-class syntax (e.g. `[?]` instead of `\?`). Backslashes can be lost or misinterpreted across the nREPL bencode transport layer, causing test discovery to fail for test names containing `?`, `*`, etc.

Enhanced current form detection to include `#_` (discard) commented forms so that operations like evaluate-current-form correctly identify the full form extent including prefixed discard comments.

Fixed toggle comment behavior when the cursor is positioned inside nested brackets or forms. Previously the comment was applied to the enclosing expression rather than the intended inner form.

Fixed the uncomment operation to correctly handle comment markers that are not in the first column, preserving the proper leading whitespace/indentation when removing `;;` prefixes.

Fixed toggle comment to work correctly when the selection is a partial, unformatted fragment rather than a complete Clojure form. Previously the operation would produce incorrect results or corrupt indentation in such cases.

Fixed an indentation glitch that occurred when toggling line comments off (removing `;;` markers). The indentation would shift incorrectly after comment removal, leaving code mis-aligned.

Fixed insert semicolon operation when a multi-line form starts at the very beginning of the file (position 0). Previously this edge case caused incorrect semicolon positioning or an error.

Fixed the "Evaluate selection" option in the editor context menu to work correctly when the selection is within or overlaps a comment form.

Fixed the insert semicolon operation to avoid breaking surrounding code structure when the cursor is positioned at a location where naive semicolon insertion would split a form.

Added comprehensive pair form support for the applied-science/js-interop library, enabling paredit operations (grow selection, drag sexp) for js-interop-specific forms. Introduced vector-binding form support for applied-science.js-interop/let and flat pair form support for applied-science.js-interop/assoc! and applied-science.js-interop/obj. Includes support for aliased forms (e.g., j/let, j/assoc!) with comprehensive test coverage.

Enhanced threading macro detection to support namespace alias resolution, allowing pair forms and threading macros to work correctly when invoked via aliases (e.g., p/-> for promesa.core/->). Added default pair form support for Promesa library forms including promesa.core/plet, promesa.core/loop, promesa.core/doseq, and promesa.core/with-redefs. Added threading macro support for promesa.core/-> and promesa.core/->>.

Unified the handling of structural prefix deletion (for both ' and #) to be consistent between backward and forward deletion operations. Refactored backspace and deleteForward functions into smaller, more maintainable functions for better code clarity.

Fixed structural backspace and deleteForward operations to correctly handle deletion of quote prefixes positioned right after quoted forms. Issue manifested when attempting operations like '()|: now the quote can be deleted properly. Added comprehensive unit tests for quoted lists, nested quoted lists, and quoted vectors.

Fixed slurp backward operation to properly handle cursor positioning when encountering #_ (ignore marker) comments. After calling backwardSexp to find the previous form, the cursor is now correctly checked if it's preceded by an #_ ignore marker, enabling reliable backward slurping with commented code.

Fixed Slurp Forward command adding an unwanted leading space when slurping into empty or whitespace-only forms. The fix detects when the target form contains no actual content (only whitespace between open and close brackets, or empty strings) and omits the leading space in that case.

Fixed Slurp Backward command adding unwanted trailing spaces when slurping into empty or whitespace-only forms. The fix detects when the target form contains no actual content and omits the trailing space in that case, bringing consistency with the forward slurp fix.

Enhanced the backspace and deleteForward functions to correctly handle deletion of reader macro hashes (#) when the cursor is positioned immediately after or before them. This prevents orphaned hashes and maintains code integrity during editing.

Comprehensive test coverage for drag sexp functionality across different form types including cond, case, condp, and :let bindings. Tests ensure proper movement of pairs and triples within conditional and binding forms.

`:as-alias` creates a namespace alias without loading the target namespace, so it cannot form a runtime dependency. The cyclic-dependencies linter was treating `:as-alias` requires as real edges, producing false cycle reports. This change excludes them from the dependency graph.

`(require ...)` calls inside `(comment ...)` forms are never evaluated, so they cannot create real namespace dependencies. The linter was walking those calls and adding edges to the dependency graph, causing false cycle reports. This change excludes usages that fall within a `comment` boundary.

Go-to-definition previously failed for fully qualified symbols like `clojure.string/join` when the namespace was not in the file's `:require` block. Added a resolver that looks up unknown namespace usages against the loaded analysis, enabling definition lookup for any qualified var reachable on the classpath.

Added a `deftest-loc-with-name` helper that locates the first top-level `(deftest <name> ...)` form in the target test file. The "Create test" code action now navigates to an existing deftest with the matching name instead of inserting a duplicate.

Detect when the first child of `:require`/`:import` sits on the same line as the keyword and preserve that style during `add-missing-libspec` so auto-clean no longer re-flows the entire ns block. Adjusted the settings update logic for `ns-inner-blocks-indentation` and `keep-require-at-start` to honor user formatting choices.

Added a language filter to require suggestions so a `.clj` file no longer offers refers defined only in `.cljs` files (and vice versa). `.cljc` files continue to see refers from both. Includes test coverage for each language combination.

Updated the bundled clj-kondo dependency to 2026年04月15日 to pull in upstream linter improvements and bug fixes.

Added a new `:kit/reagent` module to the Kit modules registry that scaffolds Reagent UIs against React 19 via `reagent.dom.client`. Spans three repos: the modules registry (kit-clj/modules#45) adds the module configuration and README entry; the Kit framework (kit-clj/kit#177) bumps React to 19 and Reagent to 2.0.1; and the documentation site (kit-clj/kit-clj.github.io#76) updates the modules page and ClojureScript guide to use the new client-rendering API and notes the legacy `reagent.dom/render` API.

Bumped `reitit` and `ring-core` to current versions in the Kit framework deps.

Resolved edge cases in task list checkbox toggling to preserve expected casing and behavior. Implemented safer replace semantics for consistent checkbox state transitions.

Enhanced autopairing logic for parentheses to only trigger in appropriate contexts (e.g., when preceded by whitespace), preventing unwanted insertions in URLs and other patterns.

Corrected image navigation logic in maximize (lightbox) mode to maintain proper order when switching between images. Fixed inconsistent index calculations causing confusing navigation.

Stubbed the base module for string requires that reach a JS module member with the `module$default` form, so a ClojureScript library that wraps npm packages no longer fails analysis. Added a fixture and a regression test. Resolves #135.