give Google Closure enough information so that type checking can work

sensibly without extra noise

Author: dnolen

src/main/cljs/cljs/core.cljs

@@ -28,11 +28,13 @@
 
 (def
   ^{:dynamic true
-    :doc "Var bound to the current namespace. Only used for bootstrapping."}
+    :doc "Var bound to the current namespace. Only used for bootstrapping."
+    :jsdoc ["@type {*}"]}
   *ns* nil)
 
 (def
-  ^{:dynamic true}
+  ^{:dynamic true
+    :jsdoc ["@type {*}"]}
   *out* nil)
 
 (def
@@ -106,7 +108,8 @@
     :doc "When set to logical true, objects will be printed in a way that preserves
   their type when read in later.
 
-  Defaults to false."}
+  Defaults to false."
+    :jsdoc ["@type {null|number}"]}
   *print-length* nil)
 
 (def
@@ -118,10 +121,14 @@
   collection, its items are at level 1; and so on. If an object is a
   collection and is at a level greater than or equal to the value bound to
   *print-level*, the printer prints '#' to represent it. The root binding
-  is nil indicating no limit."}
+  is nil indicating no limit."
+    :jsdoc ["@type {null|number}"]}
   *print-level* nil)
 
-(defonce ^:dynamic *loaded-libs* nil)
+(defonce
+  ^{:dynamic true
+    :jsdoc ["@type {*}"]}
+  *loaded-libs* nil)
 
 (defn- pr-opts []
   {:flush-on-newline *flush-on-newline*
@@ -9143,7 +9150,9 @@ reduces them without incurring seq initialization"
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; gensym ;;;;;;;;;;;;;;;;
 ;; Internal - do not use!
-(def gensym_counter nil)
+(def
+  ^{:jsdoc ["@type {*}"]}
+  gensym_counter nil)
 
 (defn gensym
   "Returns a new symbol with a unique name. If a prefix string is
@@ -9403,7 +9412,10 @@ Maps become Objects. Arbitrary keys are encoded to by key->js."
   "Creates a hierarchy object for use with derive, isa? etc."
   [] {:parents {} :descendants {} :ancestors {}})
 
-(def ^:private -global-hierarchy nil)
+(def
+  ^{:private true
+    :jsdoc ["@type {*}"]}
+  -global-hierarchy nil)
 
 (defn- get-global-hierarchy []
   (when (nil? -global-hierarchy)
@@ -9984,7 +9996,10 @@ Maps become Objects. Arbitrary keys are encoded to by key->js."
   {:pre [(symbol? tag)]}
   (TaggedLiteral. tag form))
 
-(def ^:private js-reserved-arr
+(def
+  ^{:private true
+    :jsdoc ["@type {*}"]}
+  js-reserved-arr
   #js ["abstract" "boolean" "break" "byte" "case"
        "catch" "char" "class" "const" "continue"
        "debugger" "default" "delete" "do" "double"
@@ -9999,7 +10014,9 @@ Maps become Objects. Arbitrary keys are encoded to by key->js."
        "volatile" "while" "with" "yield" "methods"
        "null"])
 
-(def js-reserved nil)
+(def
+  ^{:jsdoc ["@type {*}"]}
+  js-reserved nil)
 
 (defn- js-reserved? [x]
   (when (nil? js-reserved)
@@ -10093,7 +10110,9 @@ Maps become Objects. Arbitrary keys are encoded to by key->js."
   (-hash [_]
     (hash name)))
 
-(def NS_CACHE nil)
+(def
+  ^{:jsdoc ["@type {*}"]}
+  NS_CACHE nil)
 
 (defn- find-ns-obj* [ctxt xs]
   (cond

src/main/cljs/cljs/externs.js

@@ -1,5 +1,9 @@
 Math.imul = function(a, b) {};
 
+Object.prototype.done;
+Object.prototype.value;
+Object.prototype.next = function() {};
+
 /**
  * @constructor;
  */

src/main/clojure/cljs/core.cljc

@@ -2683,7 +2683,7 @@
                         :arglists-meta (doall (map meta [arglist]))})]
       `(do
          (def ~(with-meta name meta)
-           (fn []
+           (fn [~'var_args]
              (let [args# (array)]
                (copy-arguments args#)
                (let [argseq# (when (< ~c-1 (alength args#))
@@ -2738,7 +2738,7 @@
                args-sym (gensym "args")]
       `(do
          (def ~(with-meta name meta)
-           (fn []
+           (fn [~'var_args]
              (let [~args-sym (array)]
                (copy-arguments ~args-sym)
                (case (alength ~args-sym)
@@ -2821,16 +2821,18 @@
                     m (conj (if (meta name) (meta name) {}) m)]
            (core/cond
              (multi-arity-fn? fdecl)
-             (multi-arity-fn name m fdecl)
+             (multi-arity-fn name
+               (update-in m [:jsdoc] conj "@param {...*} var_args") fdecl)
 
              (variadic-fn? fdecl)
-             (variadic-fn name m fdecl)
+             (variadic-fn name
+               (update-in m [:jsdoc] conj "@param {...*} var_args") fdecl)
 
              :else
              (core/list 'def (with-meta name m)
-              ;;todo - restore propagation of fn name
-              ;;must figure out how to convey primitive hints to self calls first
-              (cons `fn fdecl))))))
+               ;;todo - restore propagation of fn name
+               ;;must figure out how to convey primitive hints to self calls first
+               (cons `fn fdecl))))))
 
 #?(:clj  (. (var defn) (setMacro))
    :cljs (set! (. defn -cljs$lang$macro) true))