i.e. I can see it currently doesn't, but would that be within its capabilities / design scope?

I recently made a typo with a clojure.string function, looked at clj-kondo's types.clojure.string namespace to see that it hadn't been specced yet, then saw from the clojure.string source that most functions were already hinted with ^String or ^CharSequence

This currently works:

(defn foo ^String [])
(inc (foo))

you'll get a warning about string instead of number

hmm, but (inc (string/reverse "abc")) doesn't give a warning

(defn ^String reverse
  "Returns s with its characters reversed."
  {:added "1.2"}
  [^CharSequence s]
  (.toString (.reverse (StringBuilder. s))))

huh, so there are two different places where the return type hint can go

that's because the var is hinted, not the return type

which is wrong

I think

Yeah, apparently the compiler detects that as a valid type hint 😮

(set! *warn-on-reflection* true)
(defn f1 [])
(defn f2 ^String [])
(defn ^String f3 [])

(fn []
  (.length (f1))
  (.length (f2))
  (.length (f3)))

Even though it's not documented on https://clojure.org/reference/java_interop#typehints

so the type hint on a var also gets used for inferring the return type? if you can confirm that this is correct behavior clj-kondo could adopt this

by checking this in #clojure with e.g. Alex Miller

I posted it on https://ask.clojure.org/index.php/8993/where-to-place-function-return-type-hints

Looks like the answer is yes, tags on function vars can be used to infer the return type

Although the arglist tag takes precedence

Issue welcome. After that, PR + tests also welcome.

Note that you have to re-run script/extract-var-info after making the change, so the tags will be picked up from the code.

I don't know IntelliJ well enough to answer this.

Thanks!