Same as Clojure 92df7b2a

Author: dnolen

src/main/cljs/cljs/repl.cljs

@@ -49,10 +49,8 @@
           (when doc
             (println " " doc))))
       (when n
-        (let [specs (spec/fn-specs (symbol (str (ns-name n)) (name nm)))]
-          (when (some identity (vals specs))
-            (print "Spec")
-            (run! (fn [[role spec]]
-                   (when (and spec (not (= spec ::spec/unknown)))
-                     (print (str "\n " (name role) ":") (spec/describe spec))))
-              specs)))))))
+        (when-let [fnspec (spec/fn-spec (symbol (str (ns-name n)) (name nm)))]
+          (print "Spec")
+          (doseq [role [:args :ret :fn]]
+            (when-let [spec (get fnspec role)]
+              (print (str "\n " (name role) ":") (spec/describe spec)))))))))

src/main/cljs/cljs/spec.cljc

@@ -273,10 +273,6 @@
       s
       (symbol (str (.-name *ns*)) (str s)))))
 
-(defn- fn-spec-sym
-  [env sym role]
-  (symbol (str (ns-qualify env sym) "$" (name role))))
-
 (def ^:private _speced_vars (atom #{}))
 
 (defn speced-vars*
@@ -313,7 +309,7 @@ specified, return speced vars from all namespaces."
 
   Qualifies fn-sym with resolve, or using *ns* if no resolution found.
   Registers specs in the global registry, where they can be retrieved
-  by calling fn-specs.
+  by calling fn-spec.
 
   Once registered, function specs are included in doc, checked by
   instrument, tested by the runner clojure.spec.test/run-tests, and (if
@@ -332,18 +328,11 @@ specified, return speced vars from all namespaces."
                  :str string?
                  :sym symbol?)
     :ret symbol?)"
-  [fn-sym & {:keys [args ret fn] :as m}]
+  [fn-sym & specs]
   (let [env &env
         qn  (ns-qualify env fn-sym)]
     (swap! _speced_vars conj qn)
-    `(do ~@(reduce
-             (clojure.core/fn [defns role]
-               (if (contains? m role)
-                 (let [s (fn-spec-sym env qn (name role))]
-                   (conj defns `(cljs.spec/def '~s ~(get m role))))
-                 defns))
-             [] [:args :ret :fn])
-         '~qn)))
+    `(cljs.spec/def '~qn (cljs.spec/fspec ~@specs))))
 
 (defmacro with-instrument-disabled
   "Disables instrument's checking of calls, within a scope."

src/main/cljs/cljs/spec.cljs

@@ -254,8 +254,6 @@
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; instrument ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(def ^:private fn-spec-roles [:args :ret :fn])
-
 (defn- expect
   "Returns nil if v conforms to spec, else throws ex-info with explain-data."
   [spec v]
@@ -268,25 +266,15 @@
     (.-sym x)
     x))
 
-(defn- fn-specs?
-  "Fn-specs must include at least :args or :ret specs."
+(defn- fn-spec?
+  "Fn-spec must include at least :args or :ret specs."
   [m]
   (c/or (:args m) (:ret m)))
 
-(defn- fn-spec-sym
-  [sym role]
-  (symbol (str sym "$" (name role))))
-
-(defn fn-specs
-  "Returns :args/:ret/:fn map of specs for var or symbol v."
+(defn fn-spec
+  "Returns fspec of specs for var or symbol v, or nil."
   [v]
-  (let [s (->sym v)
-        reg (registry)]
-    (reduce
-      (fn [m role]
-        (assoc m role (get reg (fn-spec-sym s role))))
-      {}
-      fn-spec-roles)))
+  (get (registry) (->sym v)))
 
 (defn- spec-checking-fn
   [v f]
@@ -304,7 +292,7 @@
         [& args]
         (if *instrument-enabled*
           (s/with-instrument-disabled
-            (let [specs (fn-specs v)]
+            (let [specs (fn-spec v)]
               (let [cargs (when (:args specs) (conform! v :args (:args specs) args args))
                     ret (binding [*instrument-enabled* true]
                           (apply f args))
@@ -317,7 +305,7 @@
 
 (defn- macroexpand-check
   [v args]
-  (let [specs (fn-specs v)]
+  (let [specs (fn-spec v)]
     (when-let [arg-spec (:args specs)]
       (when (= ::invalid (conform arg-spec args))
         (let [ed (assoc (explain-data* arg-spec [:args]
@@ -328,7 +316,7 @@
                      "Call to " (->sym v) " did not conform to spec:\n"
                      (with-out-str (explain-out ed))))))))))
 
-(defn- no-fn-specs
+(defn- no-fn-spec
   [v specs]
   (ex-info (str "Fn at " (pr-str v) " is not spec'ed.")
            {:var v :specs specs}))
@@ -339,16 +327,16 @@
 
 (defn instrument*
   [v]
-  (let [specs (fn-specs v)]
-    (if (fn-specs? specs)
+  (let [spec (fn-spec v)]
+    (if (fn-spec? spec)
       (locking instrumented-vars
                (let [{:keys [raw wrapped]} (get @instrumented-vars v)
                      current @v]
                  (when-not (= wrapped current)
                    (let [checked (spec-checking-fn v current)]
                      (swap! instrumented-vars assoc v {:raw current :wrapped checked})
                      checked))))
-      (throw (no-fn-specs v specs)))))
+      (throw (no-fn-spec v spec)))))
 
 (defn unstrument*
   [v]