fix def/fdef symbol resolution, replace fn-spec with more general get-spec

same as Clojure 4978bf5c

Author: dnolen

src/main/cljs/cljs/repl.cljs

@@ -49,7 +49,7 @@
           (when doc
             (println " " doc))))
       (when n
-        (when-let [fnspec (spec/fn-spec (symbol (str (ns-name n)) (name nm)))]
+        (when-let [fnspec (spec/get-spec (symbol (str (ns-name n)) (name nm)))]
           (print "Spec")
           (doseq [role [:args :ret :fn]]
             (when-let [spec (get fnspec role)]

src/main/cljs/cljs/spec.cljc

@@ -8,7 +8,8 @@
 
 (ns cljs.spec
   (:refer-clojure :exclude [+ * and or cat def keys resolve])
-  (:require [cljs.analyzer.api :refer [resolve]]
+  (:require [cljs.analyzer :as ana]
+            [cljs.analyzer.api :refer [resolve]]
             [clojure.walk :as walk]
             [cljs.spec.impl.gen :as gen]
             [clojure.string :as str]))
@@ -35,11 +36,22 @@
     (sequential? form) (walk/postwalk #(if (symbol? %) (res env %) %) (unfn form))
     :else form))
 
+(defn- ns-qualify
+  "Qualify symbol s by resolving it or using the current *ns*."
+  [env s]
+  (if (namespace s)
+    (let [v (resolve env s)]
+      (assert v (str "Unable to resolve: " s))
+      (->sym v))
+    (symbol (str ana/*cljs-ns*) (str s))))
+
 (defmacro def
-  "Given a namespace-qualified keyword or symbol k, and a spec, spec-name, predicate or regex-op
-  makes an entry in the registry mapping k to the spec"
+  "Given a namespace-qualified keyword or resolveable symbol k, and a spec,
+   spec-name, predicate or regex-op makes an entry in the registry mapping k to
+   the spec"
   [k spec-form]
-  `(cljs.spec/def-impl ~k '~(res &env spec-form) ~spec-form))
+  (let [k (if (symbol? k) (ns-qualify &env k) k)]
+    `(cljs.spec/def-impl '~k '~(res &env spec-form) ~spec-form)))
 
 (defmacro spec
   "Takes a single predicate form, e.g. can be the name of a predicate,
@@ -248,6 +260,9 @@
   and returns a spec whose conform/explain take a fn and validates it
   using generative testing. The conformed value is always the fn itself.
 
+  See 'fdef' for a single operation that creates an fspec and
+  registers it, as well as a full description of :args, :ret and :fn
+
   Optionally takes :gen generator-fn, which must be a fn of no args
   that returns a test.check generator."
   [& {:keys [args ret fn gen]}]
@@ -264,15 +279,6 @@
   (assert (not (empty? preds)))
   `(cljs.spec/tuple-impl '~(mapv #(res &env %) preds) ~(vec preds)))
 
-(defn- ns-qualify
-  "Qualify symbol s by resolving it or using the current *ns*."
-  [env s]
-  (if-let [resolved (resolve env s)]
-    (->sym resolved)
-    (if (namespace s)
-      s
-      (symbol (str (.-name *ns*)) (str s)))))
-
 (def ^:private _speced_vars (atom #{}))
 
 (defn speced-vars*
@@ -308,8 +314,8 @@ specified, return speced vars from all namespaces."
     expected to contain predicates that relate those values
 
   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-spec.
+  Registers an fspec in the global registry, where it can be retrieved
+  by calling get-spec with the var or full-qualified symbol.
 
   Once registered, function specs are included in doc, checked by
   instrument, tested by the runner clojure.spec.test/run-tests, and (if
@@ -329,10 +335,8 @@ specified, return speced vars from all namespaces."
                  :sym symbol?)
     :ret symbol?)"
   [fn-sym & specs]
-  (let [env &env
-        qn  (ns-qualify env fn-sym)]
-    (swap! _speced_vars conj qn)
-    `(cljs.spec/def '~qn (cljs.spec/fspec ~@specs))))
+  (swap! _speced_vars conj (ns-qualify &env fn-sym))
+  `(cljs.spec/def ~fn-sym (cljs.spec/fspec ~@specs)))
 
 (defmacro with-instrument-disabled
   "Disables instrument's checking of calls, within a scope."

src/main/cljs/cljs/spec.cljs

@@ -238,18 +238,30 @@
 (defn ^:skip-wiki def-impl
   "Do not call this directly, use 'def'"
   [k form spec]
-  (assert (c/and (named? k) (namespace k)) "k must be namespaced keyword/symbol")
+  (assert (c/and (named? k) (namespace k)) "k must be namespaced keyword or resolveable symbol")
   (let [spec (if (c/or (spec? spec) (regex? spec) (get @registry-ref spec))
                spec
                (spec-impl form spec nil nil))]
     (swap! registry-ref assoc k spec)
     k))
 
 (defn registry
-  "returns the registry map"
+  "returns the registry map, prefer 'get-spec' to lookup a spec by name"
   []
   @registry-ref)
 
+(defn- ->sym
+  "Returns a symbol from a symbol or var"
+  [x]
+  (if (var? x)
+    (.-sym x)
+    x))
+
+(defn get-spec
+  "Returns spec registered for keyword/symbol/var k, or nil."
+  [k]
+  (get (registry) (if (keyword? k) k (->sym k))))
+
 (declare map-spec)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; instrument ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -259,23 +271,11 @@
   [spec v]
   )
 
-(defn- ->sym
-  "Returns a symbol from a symbol or var"
-  [x]
-  (if (var? x)
-    (.-sym x)
-    x))
-
 (defn- fn-spec?
   "Fn-spec must include at least :args or :ret specs."
   [m]
   (c/or (:args m) (:ret m)))
 
-(defn fn-spec
-  "Returns fspec of specs for var or symbol v, or nil."
-  [v]
-  (get (registry) (->sym v)))
-
 (defn- spec-checking-fn
   [v f]
   (let [conform! (fn [v role spec data args]
@@ -292,7 +292,7 @@
         [& args]
         (if *instrument-enabled*
           (s/with-instrument-disabled
-            (let [specs (fn-spec v)]
+            (let [specs (get-spec v)]
               (when (:args specs) (conform! v :args (:args specs) args args))
               (binding [*instrument-enabled* true]
                 (apply f args))))
@@ -301,7 +301,7 @@
 
 (defn- macroexpand-check
   [v args]
-  (let [specs (fn-spec v)]
+  (let [specs (get-spec v)]
     (when-let [arg-spec (:args specs)]
       (when (= ::invalid (conform arg-spec args))
         (let [ed (assoc (explain-data* arg-spec [:args]
@@ -323,7 +323,7 @@
 
 (defn instrument*
   [v]
-  (let [spec (fn-spec v)]
+  (let [spec (get-spec v)]
     (if (fn-spec? spec)
       (locking instrumented-vars
                (let [{:keys [raw wrapped]} (get @instrumented-vars v)
@@ -1128,7 +1128,7 @@
   "Return true if start <= val and val < end"
   [start end val]
   (cond
-    (integer? val) (and (<= start val) (< val end))
+    (integer? val) (c/and (<= start val) (< val end))
 
     (instance? goog.math.Long val)
     (c/and (.lessThanOrEqual start val)