ClojureScript 1.11.60
cljs.user=> (let [a 1] (meta ^a []))
{:tag 1}

sorry, should have qualified. resolves tags for vars

Ah, right.

hmm maybe it does? I thought all analyzer metadata is dropped when generating code

ok, I guess it really does resolve those. just not for vars then

it's not quite that

metadata on def symbols is not evaluated

but on expressions it is

^foo expr is compiled more or less like if it was (with-meta expr foo)

yeah but I thought it dropped tag info just like it drops all other reader metadata (line, col, etc)

guess it does not

ClojureScript 1.11.60
cljs.user=> (meta ^js [])
WARNING: Use of undeclared Var cljs.user/js
{:tag nil}
cljs.user=> (meta ^js ())
{:tag js}

@U060FKQPN: i think the rule is that cljs evals metadata on all expressions except lists

I think empty list is just a special case

right i think it blocks metadata eval on lists for invoke exprs, and happens to catch the empty list case

nah, way earlier than that. https://github.com/clojure/clojurescript/blob/9562ae11422243e0648a12c39e7c990ef3f94260/src/main/clojure/cljs/analyzer.cljc#L4311

From that code, it seems as if the tag should've been replaced with cljs.core/IList. Why is it still js then?

I'm guessing the infer-type analyzer pass just overrides it again. since that just looks at the unevaluated form

Hmm. Or maybe :tag after that point differs from (meta form).

Does this work for documentation? > Values provided inside metadata reader macros in ClojureScript are only evaluated when they precede evaluated collection literals— except lists.

I'll give you one more:

cljs.user=> (let [a 1] (meta ^a ()))
{:tag a}
cljs.user=> (let [a 1] (meta ^a '()))
nil

I think the description still works for that then! right?

^a was attached to the quote form unevaluated, then quote evaluated to () with no metadata

err, quote wasn’t evaluated, I mean compiled probably

I modified the description to account for this:

(defn foo ^a [] 1)

[] is a collection literal but is unevaluated

Honestly, I have no idea how to describe all this without it becoming even more confusing to a reader.

I agree, but I only went down here because I saw ^js and realized my ^meta docs were wrong about evaluating symbols

I won’t put it front and center summary, but it should be a footnote in the details

I think the relevant bit is whether the "thing" ends up as a runtime thing, or is just "syntax" (ie. for macros)

yeah I like that

so in defn the ^a [] never ends up anywhere in the code. it is just used by the analyzer to define the return type

it still is just a vector with :tag a meta, but since it never ends up in the runtime its never evaluated and thus not resolved

okay, so anytime metadata reader macros are used on values available to the runtime, it’s evaluated.

and maybe not mention the empty list exception

there are other exceptions but yes

is this still related to the ^js docs? I don't think this is relevant to any of that at all. there are really only a couple places ^js should be used. maybe should just add the 3 examples for that or so? 😛

yeah I wouldn’t put any of this in the ^js doc

I realized last month that my ^meta doc was wrong though: https://github.com/cljs/api/issues/187

I said something like ^foo => ^{:tag <value at foo>}, so that’s what I’m trying to clear up there

> I think the relevant bit is whether the "thing" ends up as a runtime thing, or is just "syntax" (ie. for macros) So anytime ^a foo can be emitted as (with-meta foo {:tag a}) , you can know a is evaluated?

well thats a bad example since foo is a symbol and never actually ends up in the code 😛

Feels like all these metadata threads are a perfect source of materials for some Clojure quiz. :D

@U05224H0W dang you’re right, just when I think I understand something:

cljs.user=> (let [a 1 foo []] (with-meta foo {:tag a}))
^{:tag 1} []
cljs.user=> (let [a 1 foo []] ^a foo)
[]

I don’t think there’s a clear rule then, not one I can write at least

well the rule is that the metadata is always applied to what is read, so symbols, lists, etc

what happens with that depends on the context 😛

right, so the rule for the context would be too complicated?

well if you want to explain macros? 😛 can't really come up with a way to explain it simply

I never use it for runtime stuff, so I consider it a syntax only thing for the compiler

Is there a way to show code emitted from the repl?

oh nice, :repl-verbose

you can use something like this https://code.thheller.com/shadow-grove-playground/0.4.0/

see the "Generated JS" tab

Strange, the verbose option for repl doesn’t seem to work for me:

$ clj -M -m cljs.main --repl-opts "{:repl-verbose true}" --repl

don't know what :repl-verbose is supposed to do

docs say it should print the compiled JS: https://clojurescript.org/reference/repl-options#repl-verbose

ah. yeah dunno. not something shadow-cljs supports either 😛

That’s OK. There’s always *print-fn-bodies* 🙂

thanks, that works!

ClojureScript 1.11.60
cljs.user=> (set! *print-fn-bodies* true)
true
cljs.user=> (fn [] (let [a 1] ^a []))
#object[ret__7815__auto__ "function (){
var a = (1);
return cljs.core.with_meta(cljs.core.PersistentVector.EMPTY,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"tag","tag",-1290361223),a], null));
}"]

@U04VDQDDY taught me that one (thank you Mike!)

I added the simplest possible note as I could on this stuff here: http://cljs.github.io/api/syntax/meta