CLJS-3120: Add :sigs to protocol var for compatibility with Clojure

Renamed cljs.core/warn-and-update-protocol to something more sensible -
update-protocol-var.

Add :sigs to protocol var which matches Clojure data shape.

Add test case to cljs.analyzer-tests. Add some helpers - cached core
analysis, and analyze-forms helper to drop some boilerplate.

Author: swannodette

src/main/clojure/cljs/core.cljc

@@ -1409,7 +1409,7 @@
 (core/defn- to-property [sym]
   (symbol (core/str "-" sym)))
 
-(core/defn- warn-and-update-protocol [p type env]
+(core/defn- update-protocol-var [p type env]
   (core/when-not (= 'Object p)
     (core/if-let [var (cljs.analyzer/resolve-existing-var (dissoc env :locals) p)]
       (do
@@ -1440,7 +1440,7 @@
       ret)))
 
 (core/defn- base-assign-impls [env resolve tsym type [p sigs]]
-  (warn-and-update-protocol p tsym env)
+  (update-protocol-var p tsym env)
   (core/let [psym       (resolve p)
              pfn-prefix (subs (core/str psym) 0
                           (clojure.core/inc (.indexOf (core/str psym) "/")))]
@@ -1526,7 +1526,7 @@
         meths))))
 
 (core/defn- proto-assign-impls [env resolve type-sym type [p sigs]]
-  (warn-and-update-protocol p type env)
+  (update-protocol-var p type env)
   (core/let [psym      (resolve p)
              pprefix   (protocol-prefix psym)
              skip-flag (set (core/-> type-sym meta :skip-protocol-flag))]
@@ -2101,8 +2101,7 @@
                                         ~check)]
                             `(~sig ~check)))
              psym (core/-> psym
-                    (vary-meta update-in [:jsdoc] conj
-                      "@interface")
+                    (vary-meta update-in [:jsdoc] conj "@interface")
                     (vary-meta assoc-in [:protocol-info :methods]
                       (into {}
                         (map
@@ -2112,6 +2111,16 @@
                                        sigs (take-while vector? sigs)]
                               [(vary-meta fname assoc :doc doc)
                                (vec sigs)]))
+                          methods)))
+                    ;; for compatibility with Clojure
+                    (vary-meta assoc-in [:sigs]
+                      (into {}
+                        (map
+                          (core/fn [[fname & sigs]]
+                            (core/let [doc (core/as-> (last sigs) doc
+                                             (core/when (core/string? doc) doc))
+                                       sigs (take-while vector? sigs)]
+                              [(keyword fname) {:name fname :arglists (list* sigs) :doc doc}]))
                           methods))))
              method (core/fn [[fname & sigs]]
                       (core/let [doc (core/as-> (last sigs) doc

src/test/clojure/cljs/analyzer_tests.clj

@@ -186,6 +186,22 @@
 
 (def test-cenv (atom {}))
 (def test-env (assoc-in (ana/empty-env) [:ns :name] 'cljs.core))
+(def test-core-env (atom {}))
+
+(binding [ana/*unchecked-if* false
+          ana/*analyze-deps* false]
+  (env/with-compiler-env test-core-env
+    (comp/with-core-cljs nil
+      (fn []))))
+
+(defn core-env []
+  (atom @test-core-env))
+
+(defn analyze-forms [cenv xs]
+  (binding [ana/*unchecked-if* false
+            ana/*analyze-deps* false]
+    (env/with-compiler-env cenv
+      (ana/analyze-form-seq xs))))
 
 (ana/no-warn
   (env/with-compiler-env test-cenv
@@ -2021,4 +2037,20 @@
                               (:tag (analyze test-env '(munge-str ""))))))
   (is (= 'string
          (env/with-compiler-env test-cenv
-                              (:tag (analyze test-env '(demunge-str "")))))))
+                              (:tag (analyze test-env '(demunge-str "")))))))
+
+(deftest test-cljs-3120
+  (let [cenv (core-env)
+        _ (analyze-forms cenv
+            '[(ns goz.core)
+              (defprotocol IAlpha
+                (foo [this] "foo fn")
+                (bar [this x] "bar fn")
+                (woz [this x y] "baz fn"))])
+        sigs (get-in @cenv [::ana/namespaces 'goz.core :defs 'IAlpha :sigs])]
+    (is (= #{:foo :bar :woz} (set (keys sigs))))
+    (is (every? #(set/subset? #{:name :doc :arglists} (set (keys %))) (vals sigs)))
+    (is #(= '#{foo bar woz} (set (map :name (vals sigs)))))
+    (is #(= '#{([this] [this x] [this x y])} (set (map :arglists (vals sigs)))))
+    (is #(= '#{"foo fn" "bar fn" "baz fn"} (set (map :doc (vals sigs)))))))
+