The analysis output itself isn't cached. The cache is used to look up info about other namespaces for linting: it's only used for functionality used by clj-kondo itself. If you want to do this as a user you should implement your own cache.

The first one I've added is:

was going through the default config just now and spotted https://github.com/clj-kondo/clj-kondo/blob/master/src/clj_kondo/impl/config.clj#L44-L45

@U08BJGV6E yes.. so?

:simple-libspec false is right after the map it's supposed to be in

I'm guessing the new config linter would catch a similar one

I don't even know what this does. How do you know where it's supposed to go? ;)

Checked the impl of the linter whose config is just before it

And its indentation implies it should be in the map

ah I see it now yes, thanks

the linter doesn't catch this yet, but can be made so

I guess it would have caught it as an unknown linter. As of the linked commit, the key is in a position where a linter name should be

ah yes

let's test it out :)

It doesn't catch that specific one since the expected names are derived from this config 😂

Aah

Quite the edge case 😁

Let's just start with an example

(m/rewrite {:a 'a :b nil :c 3}

  {:a ?a :b ?b :c ?c}
  {:a ?a
   & ~[(if ?b [:b ?b])
       (if ?c [:c ?c])]})

left and right pairs are handled differently, lhs introduce bindings, rhs use bindings

what does the tilde mean in this context?

yeah, this can all be done using hooks, I'm convinced :)

it's pretty similar to core.match

Quoting: https://github.com/noprompt/meander/blob/epsilon/doc/operator-overview.md#escaping

core.match on steroids and mutagenic agents 🙂

hehe. ok.

I'll take a stab at this and you can take it further if you want.

Appreciate it. If it helps, this is what this would expand to:

(let*
  [R__15723
   (let*
     [TARGET__15718 {:a 'a, :b nil, :c 3}]
     (let*
       [T__15721
        (. TARGET__15718 valAt :c)
        T__15720
        (. TARGET__15718 valAt :b)
        T__15719
        (. TARGET__15718 valAt :a)]
       (let*
         [?a T__15719]
         (let*
           [?b T__15720]
           (let*
             [?c T__15721]
             (let*
               [form__12952__auto__ {:a ?a}]
               (merge
                 (into {} cat [[(if ?b [:b ?b]) (if ?c [:c ?c])]])
                 form__12952__auto__)))))))]
  (if (meander.match.runtime.epsilon/fail? R__15723) nil R__15723))

If there was no unquote, the code inside the vector would be quoted as symbols

.clj-kondo/meander/epsilon.clj:

(ns meander.epsilon
  (:require [clojure.string :as str]
            [clojure.walk :as walk]))

(defn collect-vars [expr]
  (let [vars (volatile! [])]
    (walk/postwalk (fn [x]
                     (when (and (symbol? x)
                                (str/starts-with? (str x) "?"))
                       (vswap! vars conj x))
                     x)
                   expr)
    @vars))

(defmacro rewrite [expr & exprs]
  (let [ret `(do ~expr
                 ~@(map (fn [[lhs rhs]]
                          `(fn ~(collect-vars lhs)
                             ~rhs))
                        (partition 2 exprs)))]
    ;; (prn ret)
    ret))

.clj-kondo/config.edn:

{:hooks {:macroexpand {meander.epsilon/rewrite meander.epsilon/rewrite}}}

this should be enough to get you started. once you have complete support, you can rewrite it into a :analyze-call hook, which would take care of better locations

Thanks, I'll try rolling with it and see how it goes

The idea is: just expand into something which makes syntactically sense, but it doesn't really have to make sense in terms of what the library exactly does