CLJS-1720: Qualify symbols and namespaced keywords in spec macros

There are currently a few symbols and namespaced keywords in the
cljs.spec macros namespace that either need to be qualified for
proper operation, or should be.

The symbols fall into the category of calls to runtime functions in
the cljs.spec namespace, and need qualification in order to avoid
the $macros suffix. These comprise with-gen and gen.

In terms of keywords, an example that causes a failure is ::kvs->map
in keys*: It resolves to :cljs.spec$macros/kvs->map which doesn't
match the :cljs.spec/kvs->map spec registered near the bottom of the
cljs.spec runtime namespace.

An example that doesn't cause an outright failure, but arguably
inhibits its proper use by client code is ::nil and ::pred in the
nilable macro. Ideally these would resolve to :cljs.spec/nil and
:cljs.spec/pred so that client code can rely on these namespaced
symbols identifying the branches.

Given the nilable example, you could argue that the intent is that
all namespaced keywords in the cljs.spec macro namespace that employ
:: resolve in :cljs.spec so that they can be used not simply as
unique identifiers (the intent is not simply to avoid potential
collisions), but so that they can be used as stable identifiers.

The set of keywords that should be qualified comprises: ::kind-form,
::kfn, ::conform-all, ::kvs->map, ::nil, and ::pred

Author: mfikes

src/main/cljs/cljs/spec.cljc

@@ -223,7 +223,7 @@
   See also - coll-of, every-kv
 "
   [pred & {:keys [into kind count max-count min-count distinct gen-max gen-into gen] :as opts}]
-  (let [nopts (-> opts (dissoc :gen) (assoc ::kind-form `'~(res &env (:kind opts))))]
+  (let [nopts (-> opts (dissoc :gen) (assoc :cljs.spec/kind-form `'~(res &env (:kind opts))))]
     `(cljs.spec/every-impl '~pred ~pred ~nopts ~gen)))
 
 (defmacro every-kv
@@ -234,7 +234,7 @@
   See also - map-of"
 
   [kpred vpred & opts]
-  `(every (tuple ~kpred ~vpred) ::kfn (fn [i# v#] (nth v# 0)) :into {} ~@opts))
+  `(every (tuple ~kpred ~vpred) :cljs.spec/kfn (fn [i# v#] (nth v# 0)) :into {} ~@opts))
 
 (defmacro coll-of
   "Returns a spec for a collection of items satisfying pred. Unlike
@@ -248,7 +248,7 @@
 
   See also - every, map-of"
   [pred & opts]
-  `(every ~pred ::conform-all true ~@opts))
+  `(every ~pred :cljs.spec/conform-all true ~@opts))
 
 (defmacro map-of
   "Returns a spec for a map whose keys satisfy kpred and vals satisfy
@@ -261,7 +261,7 @@
 
   See also - every-kv"
   [kpred vpred & opts]
-  `(every-kv ~kpred ~vpred ::conform-all true :kind map? ~@opts))
+  `(every-kv ~kpred ~vpred :cljs.spec/conform-all true :kind map? ~@opts))
 
 (defmacro *
   "Returns a regex op that matches zero or more values matching
@@ -415,13 +415,13 @@
   {:i1 42, :m {:a 1, :c 2, :d 4}, :i2 99}"
   [& kspecs]
   `(let [mspec# (keys ~@kspecs)]
-     (with-gen (cljs.spec/& (* (cat ::k keyword? ::v cljs.core/any?)) ::kvs->map mspec#)
-       (fn [] (gen/fmap (fn [m#] (apply concat m#)) (gen mspec#))))))
+     (cljs.spec/with-gen (cljs.spec/& (* (cat :cljs.spec/k keyword? :cljs.spec/v cljs.core/any?)) :cljs.spec/kvs->map mspec#)
+       (fn [] (gen/fmap (fn [m#] (apply concat m#)) (cljs.spec/gen mspec#))))))
 
 (defmacro nilable
   "returns a spec that accepts nil and values satisfiying pred"
   [pred]
-  `(and (or ::nil nil? ::pred ~pred) (conformer second)))
+  `(and (or :cljs.spec/nil nil? :cljs.spec/pred ~pred) (conformer second)))
 
 (defmacro inst-in
   "Returns a spec that validates insts in the range from start
@@ -466,4 +466,4 @@
                     fspec)
           f#     ~sym]
       (for [args# (gen/sample (gen (:args fspec#)) ~n)]
-        [args# (apply f# args#)]))))
+        [args# (apply f# args#)]))))