well the ideal thing is to fix them

you can disable them via :compiler-options {:infer-externs false}, not inside :warnings. true also disables them. I know its weird. if you are sure you don't need any externs in an ns you can also do (set! *warn-on-infer* false) in the file after the ns

do you have some examples for me? maybe the recent changes I did now show too many warnings?

Thank you for getting me a helping hand so quickly. 🙂 Disabling them via :compiler-options {:infer-externs false} works like a charm! Now when no infer warnings are shown it'll be super comfy to notice other kind of warnings (like :undeclared-var etc.) ^.^ (which show up before :infer-warnings), previously you'd need to scroll up through those 28 infer warns to get to them, which, interestingly, you get used to after a while and stop to notice 😄, but still I've been getting infer warnings while watching :testhttps://github.com/logseq/logseq/blob/9f18a707aa2f4704f7ab126e9a9c49ba9bc20ff6/shadow-cljs.edn#L70, via clj -M:test watch test, as suggested in https://github.com/logseq/logseq/blob/master/docs/dev-practices.md#focus-tests. Log's attached. Hope this can be of help. 🙂 And thanks again for the tip! A solid bump to devUX (Btw, I think it's a good thing that compiler thoroughly warns about infers, these warns are there for a reason, fixing them would be nice indeed)

those all look like legit warnings to me that should be properly fixed

ignoring them will inevitably lead to problems if you ever do a :advanced build

(fn [a b] (.multipliedBy a b)) just becomes (fn [^js a b] (.multipliedBy a b)) and the warning is gone

Ah, and building without infers lead to a broken build (although I thought it would only break with :advanced, and here we've got :none , it seems, huh)

ReferenceError: js is not defined
    at /home/user1/gits/logseq/logseq/.shadow-cljs/builds/test/dev/out/cljs-runtime/malli.util.js:1834:1
    at global.SHADOW_IMPORT (/home/user1/gits/logseq/logseq/static/tests.js:64:44)
    at /home/user1/gits/logseq/logseq/static/tests.js:1764:1
    at Object.<anonymous> (/home/user1/gits/logseq/logseq/static/tests.js:2134:3)
    at Module._compile (node:internal/modules/cjs/loader:1218:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1272:10)
    at Module.load (node:internal/modules/cjs/loader:1081:32)
    at Function.Module._load (node:internal/modules/cjs/loader:922:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:82:12)
    at node:internal/main/run_main_module:23:47

I very much doubt this has anything to do with externs inference

definitely not for :none, as no externs are ever needed

you can set :infer-externs true, which will still do externs inference but never warn

that makes sense, likely I messed up something in code, sorry for the confusion, compiling now with both :infer-externs set to true and false yields no warns and the build works alright

thanks for introducing to what :infer-externs true does, logic behind true false keywords clicked 🙂

------ WARNING #3 - :infer-warning ---------------------------------------------
 File: /Users/m/code/arcstudiopro/src/app/system/spellcheck.cljs:180:3
--------------------------------------------------------------------------------
 177 | ;;       (outbox [[:spellcheck/learned params]]))))
 178 | ;;
 179 | (defn learn [{:keys [!dict ^js FS] :as system} params outbox]
 180 |   (go
---------^----------------------------------------------------------------------
 Cannot infer target type in expression (. inst_10004 (appendFile inst_10024 inst_10025))
--------------------------------------------------------------------------------
 181 |     (let [^js FS+ (.-promises FS)
 182 |           ^js dict @!dict
 183 |           word (:word params)]
 184 |       (<p! (.add dict word))
--------------------------------------------------------------------------------

(defn learn [{:keys [!dict ^js FS] :as system} params outbox]
  (go
    (let [^js FS+ (.-promises FS)
          ^js dict @!dict
          word (:word params)]
      (<p! (.add dict word))
      (<p! (.appendFile FS+ (user-dic-path system) (str word "\n")))
      (outbox [[:spellcheck/learned params]]))))

oddly, dict can be inferred as externable, but FS+ can't? or am I misreading the situation?

I tried moving the system destructuring inside the go-block, which didn't help

hmm yeah typehints in go are dropped by go unfortunately

may I suggest not using go in the above example at all? if all you do is await a promise then it is absolute overkill to do so

(defn learn [{:keys [!dict ^js FS] :as system} params outbox]
  (let [^js FS+ (.-promises FS)
        ^js dict @!dict
        word (:word params)]
    (-> (.add dict word)
        (.then #(.appendFile FS+ (user-dic-path system) (str word "\n")))
        (.then #(outbox [[:spellcheck/learned params]])))))

it'll also be like 1/100th of the generated code size 😉

.add just doesn't require externs while .appendFile does

yeah, makes sense. I do have one other situation where awaits are chained, though. any workaround for go blocks in such situations, or just deal nested thens?

I'd use https://clojureverse.org/t/promise-handling-in-cljs-using-js-await/8998 personally 😉

(defn learn [{:keys [!dict ^js FS] :as system} params outbox]
  (let [^js FS+ (.-promises FS)
        ^js dict @!dict
        word (:word params)]
    (js-await [_ (.add dict word)]
      (js-await [_ (.appendFile FS+ (user-dic-path system) (str word "\n"))]
        (outbox [[:spellcheck/learned params]])))))

note that they are already chained above with .then, so not sure what you mean

thanks!

> or just deal nested thens I think it might help to see Promises at work from the JavaScript side of things. Not totally clear if the phrase "nested then" even has any real meaning in JavaScript.

myPromise.then(x =>
  x.then(y =>
    y.then(z =>
      f(z))))

myPromise.then(f)

myPromise.then(x =>
  transformX(x)
    .then(y =>
      transformY(y)
        .then(z =>
          transformZ(z))))

myPromise
  .then(transformX)
  .then(transformY)
  .then(transformZ)

async function () {
  const x = await promise1
  const y = await promise2
  const z = await promise3
  return {x, y, z}
}

promise1.then(x =>
  promise2.then(y =>
    promise3.then(z =>
      {x, y, z})))

Promise.all([promise1, promise2, promise3])
  .then(
    ([x, y, z]) => {x, y, z})

Looks like https://clojure.atlassian.net/browse/CLJS-2351 might encompass it as well as the subsequent discussion in https://ask.clojure.org/index.php/6265/setting-arglists-metadata-when-vararg-is-present To answer @U05224H0W's question as to why it is useful... I have an https://github.com/teknql/plasma which exposes a macro that functions as a custom defn (`defhandler`). In clojure land it is basically just defn but in the front-end it packages up all the arguments into a vector and sends them to an API endpoint that calls the function on the backend and returns the results and wraps it in a JS promise. The function generated on the clojurescript side is variadic (easier to package up in the vector that performs the RPC) but since tooling (cider in this case) uses the :arglists for auto-completion / docs I would like to be able to keep the original version. I hadn't found the thread before I asked here so I'll look into a non-variadic way

Please don't cross-post. When you aren't sure where to post something, choose the most specific channel first. Given that you've provided more details in this particular thread and seem to have found a way forward, I'm removing your message in #C03S1L9DN.

#C07UQ678E would be the proper channel for this. this is not something I can do anything about from the shadow-cljs side, needs to be done in the CLJS compiler itself.