Clojurians Log v2

Got it, that's super 🆒 cool. Associating it with the java class would be great, from what I see in the data currently there is no type information. Our codebase (perhaps unsurprisingly) has more than one implementation of next and hasNext, knowing which interface and which concrete type would be neat. It also seems that currently the best way to infer the caller is by the :name-row, which strikes me as perhaps a little to 'implicit', though I'd have to go further into trying to build the graph - for example, Morpheus (mentioned and linked above) uses the :`from` and :to keys to build the graph of var usages. Perhaps having something similar here would also be helpful. You two are amazing, and I really appreciate your thoughts.

thanks! Yeah, agreed, if we had the concrete info about the instance we would manage to have multiple features on clojure-lsp like completion, find definition, references etc, it's something I'd love to see indeed, but it's a little bit complex I think as we need to track during analysis the instance (if we really can infer that safely)

clj-kondo already has some kind of tracking, but not about java types

more about number/string/map/vector etc

there is actually the :instance-invocations arg in :analysis that add info about the .hasNext and next but it's limited, so not sure it it's enough for you

clojure-lsp make usage of that https://github.com/clojure-lsp/clojure-lsp/blob/336a2731328705decef8ad009edb8ab5565af66c/lib/src/clojure_lsp/kondo.clj#L352

oh thanks for adding that :)

oh, I saw that and tried it, but I must have flubbed it. I tried it again on the small example above and it did add some data to the end file:

:instance-invocations
  [{:method-name "hasNext",
    :filename "./src/core.clj",
    :name-row 11,
    :name-col 12,
    :name-end-row 11,
    :name-end-col 20}
   {:method-name "next",
    :filename "./src/core.clj",
    :name-row 12,
    :name-col 9,
    :name-end-row 12,
    :name-end-col 14}
   {:method-name "next",
    :filename "./src/core.clj",
    :name-row 12,
    :name-col 19,
    :name-end-row 12,
    :name-end-col 24}
   {:method-name "next",
    :filename "./src/core.clj",
    :name-row 12,
    :name-col 29,
    :name-end-row 12,
    :name-end-col 34}]

I think it should be possible somehow since lsp implements call-graph features on top of this and also this tool does it: https://github.com/benedekfazekas/morpheus Perhaps @ericdallo can tell you more. Have to run now, back later

Cool, thanks!

Morpheus is rad - hadn't seen that, thank you. Here is its output for the b function:

This agrees with what I'm seeing in the raw data (no mention of a's usage of hasNext or next).

that's right, instance methods aren't included in the analysis yet

Thanks for confirming that, very helpful. I'm still a bit of a n00b here. I really appreciate your effort with this lib (and everything else!). I will ponder this further.

we could add this information, but so far it hasn't been that useful since clj-kondo doesn't know the type of many interop-related things on which method calls are called

That makes sense. In this simple example, the types are not that important (it's clear sort of just by looking at it what's going on)... In the bigger codebase there could be additional wrinkles as I believe there are multiple (different) interfaces with same-named methods in them. The call sites (even in the simple example) expand to (. s next) , which is a bit impoverished. But perhaps there's enough context in the analyzer at that point to know that s is a SillyIter ?

right now there probably isn't since it was never important enough so far

I see. Let me ponder this, and if it's important to us we can contribute some effort. Thanks!