CLJS-3438: Inference for goog.object/containsKey returns any, not boolean

- fix desugar-dotted-expr, generated malformed AST in the case of goog.module var
- compiler test for goog.object/containsKey
- uncomment test now passes

... but compiler-tests are failing due
to warning about incorrect usage of
goog.object/get, but that's because
we don't parse options params yet

also need to resolve to the original
goog.module var name and not the local
thing in the namespace

Author: swannodette

src/main/clojure/cljs/analyzer.cljc

@@ -1214,9 +1214,11 @@
 
 (defmethod resolve* :goog-module
   [env sym full-ns current-ns]
-  {:name (symbol (str current-ns) (str (munge-goog-module-lib full-ns) "." (name sym)))
-   :ns current-ns
-   :op :var})
+  (let [sym-ast (gets @env/*compiler* ::namespaces full-ns :defs (symbol (name sym)))]
+    (merge sym-ast
+      {:name (symbol (str current-ns) (str (munge-goog-module-lib full-ns) "." (name sym)))
+       :ns   current-ns
+       :op   :var})))
 
 (defmethod resolve* :global
   [env sym full-ns current-ns]
@@ -3946,14 +3948,20 @@
                       {:op :host-field
                        :env (:env expr)
                        :form (list '. prefix field)
-                       :target (desugar-dotted-expr (-> expr
+                       ;; goog.module vars get converted to the form of
+                       ;; current.ns/goog$module.theDef, we need to dissoc
+                       ;; actual extern var info so we get something well-formed
+                       :target (desugar-dotted-expr (-> (dissoc expr :info)
                                                         (assoc :name prefix
                                                                :form prefix)
                                                         (dissoc :tag)
                                                         (assoc-in [:info :name] prefix)
                                                         (assoc-in [:env :context] :expr)))
                        :field field
                        :tag (:tag expr)
+                       ;; in the case of goog.module var if there is :info,
+                       ;; we need to adopt it now as this is where :ret-tag info lives
+                       :info (:info expr)
                        :children [:target]})
                     expr)
     ;:var

src/test/clojure/cljs/compiler_tests.clj

@@ -391,6 +391,16 @@
                      (if (gstring/contains "foobar" "foo") true false)]))]
       (is (nil? (re-find #"truth_" code))))))
 
+(deftest test-goog-module-infer-cljs-3438
+  (testing "goog.object/containKey requires correct handling of vars from
+  goog.module namespace"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                 (compile-form-seq
+                   '[(ns test.foo
+                       (:require [goog.object :as gobject]))
+                     (if (gobject/containsKey nil nil) true false)]))]
+      (is (nil? (re-find #"truth_" code))))))
+
 ;; CLJS-1225
 
 (comment

src/test/clojure/cljs/type_inference_tests.clj

@@ -403,14 +403,11 @@
                       (:require [goog.string :as gstring]))
                     (gstring/contains "foobar" "foo")]
                   {} true)))))
-  ;; FIXME: infers any instead of boolean, nothing wrong w/ the externs parsing
-  ;; but this definitely does not work at the moment
-  #_(is (= 'boolean
+  (is (= 'boolean
         (:tag
           (env/with-compiler-env (env/default-compiler-env)
             (ana/analyze-form-seq
               '[(ns test.foo
                   (:require [goog.object :as gobject]))
                 (gobject/containsKey (js-object) "foo")]
               {} true))))))
-