* can finally resolve crypto.subtle

Author: swannodette

src/main/clojure/cljs/analyzer.cljc

@@ -1056,7 +1056,8 @@
                      (and (empty? (next pre))
                           (not (contains? ret :info)))
                      (assoc :info info'))]
-           (if (and (:ctor info') (= 'Function (:tag info')))
+           ;; handle actual occurrences of types, i.e. `Console`
+           (if (and (or (:ctor info') (:iface info')) (= 'Function (:tag info')))
              (or
                ;; then check for "static" property
                (resolve-extern (next pre) externs' top
@@ -1072,11 +1073,14 @@
                    (assoc ret :resolved []))))
 
              (or
-               ;; If the tag isn't Function or undefined,
-               ;; try to resolve it similar to the super case above
+               ;; If the tag of the property isn't Function or undefined,
+               ;; try to resolve it similar to the super case above,
+               ;; this handles singleton cases like `console`
                (let [tag (:tag info')]
                  (when (and tag (not (contains? '#{Function undefined} tag)))
-                   (resolve-extern (into [tag] (next pre)) externs top
+                   ;; check prefix first, during cljs.externs parsing we always generate prefixes
+                   ;; for tags because of types like webCrypto.Crypto
+                   (resolve-extern (into (or (-> tag meta :prefix) [tag]) (next pre)) externs top
                      (assoc ret :resolved []))))
 
                ;; assume static property

src/main/clojure/cljs/externs.clj

@@ -61,12 +61,23 @@
   (and (= type :string-lit)
        (= "undefined" value)))
 
+(defn add-prefix
+  "Externs inference uses :prefix meta to both resolve externs as well as generate
+  missing externs information. Google Closure Compiler default externs includes
+  nested types like webCrypto.Crypto. Add prefix information to the returned symbol to
+  simplify resolution later."
+  [type-str]
+  (with-meta (symbol type-str)
+    {:prefix (->> (string/split (name type-str) #"\.")
+               (map symbol) vec)}))
+
 (defn simplify-texpr
   [texpr]
   (case (:type texpr)
-    :string-lit    (some-> (:value texpr) symbol)
-    (:star :qmark) 'any
-    :bang          (simplify-texpr (-> texpr :children first))
+    :string-lit    (some-> (:value texpr) add-prefix)
+    :star          'any
+    ;; TODO: qmark should probably be #{nil T}
+    (:qmark :bang) (simplify-texpr (-> texpr :children first))
     :pipe          (let [[x y] (:children texpr)]
                      (if (undefined? y)
                        (simplify-texpr x)

src/test/clojure/cljs/externs_infer_tests.clj

@@ -75,7 +75,9 @@
     (is (= '[Console prototype log]
             (-> (ana/resolve-extern '[console log] externs) :resolved)))
     (is (= '[undefined]
-            (-> (ana/resolve-extern '[undefined] externs) :resolved)))))
+            (-> (ana/resolve-extern '[undefined] externs) :resolved)))
+    (is (= '[webCrypto Crypto prototype subtle]
+            (-> (ana/resolve-extern '[crypto subtle] externs) :resolved)))))
 
 (comment
   (clojure.test/test-vars [#'test-resolve-extern])