clojure-lsp.refactor.edit — com.github.clojure-lsp/clojure-lsp-test-helper 2025.04.23-18.16.46-alpha3

back-to-mark-or-nil clj

(back-to-mark-or-nil zloc marker)

find-at-pos clj

(find-at-pos zloc row col)

Find the deepest zloc whose node is at the given row and col, seeking from initial zipper location zloc.

This is similar to z/find-last-by-pos, but is faster, and doesn't require {:track-position? true}.

find-at-usage clj

(find-at-usage zloc usage)

find-at-usage-name clj

(find-at-usage-name zloc usage)

find-by-heritability clj

(find-by-heritability start-zloc inherits?)

Find the leftmost deepest zloc from start-zloc that satisfies inherits?. inherits? must be a function such that if zloc satisifies it then so will all of its ancestors.

If a parent node satisifies inherits? but none of its children do, then this returns the parent, on the assumption that the parent is the last in its lineage with the trait.

If a parent node doesn't satisfy inherits? then none of its descendants will be inspected. Instead, the search will continue with its sibling to the z/right*. As such, this algoritihm can be much faster than ones based on z/next*, which must inspect all descendants, even if information in the parent excludes the entire family.

find-function-usage-name-loc clj

(find-function-usage-name-loc zloc)

find-namespace clj

(find-namespace zloc)

find-op clj

(find-op zloc)

find-ops-up clj

(find-ops-up zloc & op-strs)

find-refer-ns clj

(find-refer-ns zloc)

find-var-definition-name-loc clj

(find-var-definition-name-loc loc)

in-range? clj

(in-range? {:keys [row col end-row end-col] :as _a}
           {r :row c :col er :end-row ec :end-col :as _b})

True if b is contained within a.

inside-rcf? clj

(inside-rcf? zloc)

inside-refer? clj

(inside-refer? zloc)

inside-require? clj

(inside-require? zloc)

join-let clj

(join-let let-loc)

if a let is directly above a form, will join binding forms and remove the inner let

loc-encapsulates-usage? clj

(loc-encapsulates-usage? loc usage)

map-children clj

(map-children parent-zloc f)

mark-position clj

(mark-position zloc marker)

mark-position-when clj

(mark-position-when zloc marker p?)

marked? clj

(marked? loc marker)

node-marked? clj

(node-marked? node marker)

parent-let? clj

(parent-let? zloc)

raise clj

(raise zloc)

Delete siblings and raise node at zloc one level up

• [1 [2 |3 4]] => [1 |3]

range-from-usage-name clj

(range-from-usage-name usage)

range-with-left-whitespace clj

(range-with-left-whitespace zloc)

root? clj

(root? loc)

single-child? clj

(single-child? zloc)

to-root clj

(to-root loc)

Returns the loc of the root :forms node.

to-top clj

(to-top loc)

Returns the loc for the top-level form above the loc, or the loc itself if it is top-level, or nil if the loc is at the :forms node.

to-top-or-subzip-top clj

(to-top-or-subzip-top loc)

to-top will return nil within a subzip, sometimes that is unwanted

top? clj

(top? loc)

var-name-loc-from-op clj

(var-name-loc-from-op loc)

wrap-around clj

(wrap-around zloc tag)

z-replace-preserving-meta clj

(z-replace-preserving-meta zloc replacement)