There is a function called api/resolve which you can feed a symbol

Oh interesting, let me see if that does what I need

yes, that works great, thank you

coming back to this, api/resolve will resolve the namespace, but it won't resolve the symbol.

given:

(ns example.foo
  (:require [example.bar :as e.bar]))

(defn create-service
  [this]
  (with-meta this {`e.bar/real-function identity}))

i realize this is outside of my original request

you can check api/ns-analysis if the var exists or not, but if the analysis is there, depends on if the namespace has already been linted before

a little awkward but works great

thanks so much

Do you mean if I'm interested in receiving a PR for it?

well, i'm not going to write a PR if you wouldn't merge it lol

i'd prefer to check if you're like "no, not interested at all" vs "maybe if it's workable", you know?

I'm not sure if this pattern is common enough (and applicable across dialects) to make huge changes. Perhaps we can just make bespoke support for some of the namespaces in clojure that use this pattern, but I'm open to having it generally supported. Not sure how easy that is though

yeah, with parallel analysis, i don't think it's possible, so i'm not sure how it would work in that case.

parallel analysis doesn't lint stuff in parallel from the same jar file or directory

oh really? so passing --parallel when linting my src folder doesn't do anything?

that's correct

okay, then maybe this is possible.

there's also this slightly related issue https://github.com/clj-kondo/clj-kondo/issues/2284

i missed that!

the strategy for parallel linting could be entirely based on topological sorting

this is probably not an issue that can be tackled in a few hours though, but willing to think about it for the long term

topological sorting dependencies in the face of load-file is very chicken and the egg

true

To properly handle it, you’d have to sort of duplicate the evaluation logic of clojure, right? Take in a file, process each form one at a time, load files when encountering load/require/use etc

sure, meaning you would need to do analysis to determine dependencies (it is already the case you need to at least analyze the ns form) and you need dependencies in order to do some kind of topo sort, and you need some kind of topo sort to determine what is safe to analyze in parallel

Right

I implemented this in splint, it didn’t increase serial linting time noticeably (~100ms per 100 files), but it did remove the ability to lint files in parallel (which i do across all files (not just per directory like in clj-kondo))

have you seen the build system's a la carte paper? (https://www.microsoft.com/en-us/research/uploads/prod/2018/03/build-systems.pdf) it is very haskell, but it might give you some interesting ideas for structuring analysis where dependencies might be dynamically discoverable, and if I recall one of the concerns presented is wanting to parallelize builds

I’ve not, I’ll give that a read.

The code complexity increase was mild to moderate: instead of just linting each form recursively, i had to first check if a given form was one that loaded other files, and then actually update the ctx with the files to lint and files that have been linted. The code that processed loading was pretty easy tho it required a bit of work to fake a classpath awareness

I haven’t merged the code because it’s currently only a speed decrease for no gain (i don’t do any var/locals tracking), but it was good to see that it’s both possible and fairly easy

I could try doing this in clj-kondo if @U04V15CAJ is interested

yeah. I think identifying groups of dependencies that still can be linted in parallel might also be nice

this won't mean much without knowing splint's internals, but here's the PR i did showing "loading in dependency order": https://github.com/NoahTheDuke/splint/pull/9

Example form:

(defresolver field/account-name
  [...]
  ...)

try:

{:config-in-call {foobar/defresolver {:linters {:syntax {:level :off}}}}}

Thanks. Will that disable syntax warnings for the whole defresolver form? There's no way to be more fine-grained about what to disable, right?

Or rather, there's no way to tell clj-kondo "A / in a symbol is ok in this foobar/defresolver"? I assume not, but just checking.

currently there is no fine-grained way

you could however write a hook for it and transform the expression to something else

here's a hook i wrote which does this:

(ns hooks.noahtheduke.splint.rules
  (:require
    [clj-kondo.hooks-api :as api]))

(defn defrule
  [{:keys [node]}]
  (let [[defrule rule-name & body] (:children node)
        new-node (api/list-node
                   (list* (with-meta (api/token-node 'def) (meta defrule))
                          (with-meta (api/token-node (symbol (name (api/sexpr rule-name))))
                                     (meta rule-name))
                          body))]
    {:node (with-meta new-node (meta node))}))

given (defrule style/eq-nil ...), it'll be treated as (def eq-nil ...)

this works for me because i have each defrule in separate files. if you need them to be in the same file, you could transform in some other way

Thanks!