* fix resolve-extern behavior for resolving the var info

  - we only care about var info for the last property
  - we don't what prefix resolution to clobber the actual instance var info
* remove js-tag, incomplete, instead use resolve-extern

Author: swannodette

src/main/clojure/cljs/analyzer.cljc

@@ -1033,7 +1033,7 @@
   "Given a foreign js property list, return a resolved js property list and the
   extern var info"
   ([pre externs]
-   (resolve-extern pre externs externs {:resolved [] :info nil}))
+   (resolve-extern pre externs externs {:resolved []}))
   ([pre externs top ret]
    (cond
      (empty? pre) ret
@@ -1044,43 +1044,43 @@
          (not me) nil
          :else
          (let [[x' externs'] me
-               info' (meta x')]
+               info' (meta x')
+               ret (cond-> ret
+                     ;; we only care about var info for the last property
+                     ;; also if we already added it, don't override it
+                     ;; because we're now resolving type information
+                     ;; not instance information anymore
+                     ;; i.e. [console] -> [Console] but :tag is Console _not_ Function vs.
+                     ;; [console log] -> [Console prototype log] where :tag is Function
+                     (and (empty? (next pre))
+                          (not (contains? ret :info)))
+                     (assoc :info info'))]
            (if (and (:ctor info') (= 'Function (:tag info')))
              (or
                ;; then check for "static" property
                (resolve-extern (next pre) externs' top
-                 (-> ret
-                   (update :resolved conj x)
-                   (assoc :info info')))
-
-                 ;; first look for a property on the prototype
-                 (resolve-extern (into '[prototype] (next pre)) externs' top
-                   (-> ret
-                     (update :resolved conj x)
-                     (assoc :info nil)))
-
-                 ;; finally check the super class if there is one
-                 (when-let [super (:super info')]
-                   (resolve-extern (into [super] (next pre)) externs top
-                     (-> ret
-                       (assoc :resolved [])
-                       (assoc :info nil)))))
+                 (update ret :resolved conj x))
+
+               ;; first look for a property on the prototype
+               (resolve-extern (into '[prototype] (next pre)) externs' top
+                 (update ret :resolved conj x))
+
+               ;; finally check the super class if there is one
+               (when-let [super (:super info')]
+                 (resolve-extern (into [super] (next pre)) externs top
+                   (assoc ret :resolved []))))
 
              (or
                ;; If the tag isn't Function or undefined,
                ;; try to resolve it similar to the super case above
                (let [tag (:tag info')]
                  (when (and tag (not (contains? '#{Function undefined} tag)))
                    (resolve-extern (into [tag] (next pre)) externs top
-                     (-> ret
-                       (assoc :resolved [])
-                       (assoc :info nil)))))
+                     (assoc ret :resolved []))))
 
                ;; assume static property
                (recur (next pre) externs' top
-                 (-> ret
-                   (update :resolved conj x)
-                   (assoc :info info')))))))))))
+                 (update ret :resolved conj x))))))))))
 
 (defn has-extern?*
   [pre externs]
@@ -1101,12 +1101,8 @@
   ([pre tag-type externs]
    (js-tag pre tag-type externs externs))
   ([pre tag-type externs top]
-   (when-let [[p externs' :as me] (find externs (first pre))]
-     (let [tag (-> p meta tag-type)]
-       (if (= (count pre) 1)
-         (when tag (symbol "js" (str (alias->type tag tag))))
-         (or (js-tag (next pre) tag-type externs' top)
-             (js-tag (into '[prototype] (next pre)) tag-type (get top tag) top)))))))
+   (when-let [tag (get-in (resolve-extern pre externs) [:info tag-type])]
+     (symbol "js" (str (alias->type tag tag))))))
 
 (defn dotted-symbol? [sym]
   (let [s (str sym)]

src/test/clojure/cljs/externs_infer_tests.clj

@@ -82,9 +82,16 @@
                     {:externs ["src/test/externs/test.js"]}))]
     (is (= 'js/Console (ana/js-tag '[console] :tag externs)))
     (is (= 'js/Function (ana/js-tag '[console log] :tag externs)))
+    (is (= 'js/undefined (ana/js-tag '[console log] :ret-tag externs)))
     (is (= 'js/Boolean (ana/js-tag '[Number isNaN] :ret-tag externs)))
     (is (= 'js/Foo (ana/js-tag '[baz] :ret-tag externs)))))
 
+(comment
+
+  (clojure.test/test-vars [#'test-js-tag])
+
+  )
+
 (defn infer-test-helper
   [{:keys [forms externs warnings warn js-dependency-index node-module-index with-core? opts]}]
   (let [test-cenv (atom