Return candidate metadata along with completions

Fixes #12.

Author: cichli

src/cljs_tooling/complete.clj

@@ -3,23 +3,131 @@
   (:require [cljs-tooling.util.analysis :as a]
             [cljs-tooling.util.misc :as u]))
 
+(defn- candidate-data
+  "Returns a map of candidate data for the given arguments."
+  [candidate ns qualified-name type]
+  {:candidate (name candidate)
+   :ns (symbol ns)
+   :name (symbol qualified-name)
+   :type type})
+
+(defn- var->type
+  "Returns the candidate type corresponding to the given metadata map."
+  [var]
+  (condp #(get %2 %1) var
+    :protocol :protocol-fn
+    :fn-var :fn
+    :record :record
+    :protocols :type
+    :protocol-symbol :protocol
+    :var))
+
 (def special-forms
   '#{& . case* catch def defrecord* deftype* do finally fn* if js* let*
      letfn* loop* new ns quote recur set! throw try})
 
-(defn prefix-completions
-  [prefix completions]
-  (map #(symbol (str prefix "/" %)) completions))
+(def special-form-candidates
+  "Candidate data for all special forms."
+  (for [form special-forms
+        :let [qualified-name (symbol "cljs.core" (name form))]]
+    (candidate-data form qualified-name 'cljs.core :special)))
+
+(defn all-ns-candidates
+  "Returns candidate data for all namespaces in the environment."
+  [env]
+  (for [[ns _] (a/all-ns env)]
+    (candidate-data ns ns ns :ns)))
+
+(defn ns-candidates
+  "Returns candidate data for all referred namespaces (and their aliases) in context-ns."
+  [env context-ns]
+  (for [[alias ns] (a/ns-aliases env context-ns)]
+    (candidate-data alias ns ns :ns)))
+
+(defn macro-ns-candidates
+  "Returns candidate data for all referred macro namespaces (and their aliases) in
+  context-ns."
+  [env context-ns]
+  (for [[alias ns] (a/macro-ns-aliases env context-ns)]
+    (candidate-data alias ns ns :ns)))
+
+(defn referred-var-candidates
+  "Returns candidate data for all referred vars in context-ns."
+  [env context-ns]
+  (for [[refer qualified-name] (a/referred-vars env context-ns)
+        :let [ns (namespace qualified-name)
+              type (var->type (a/find-var env qualified-name))]]
+    (candidate-data refer ns qualified-name type)))
+
+(defn referred-macro-candidates
+  "Returns candidate data for all referred macros in context-ns."
+  [env context-ns]
+  (for [[refer qualified-name] (a/referred-macros env context-ns)
+        :let [ns (namespace qualified-name)]]
+    (candidate-data refer ns qualified-name :macro)))
+
+(defn- var-candidates
+  [vars]
+  (for [[name meta] vars
+        :let [qualified-name (:name meta)
+              ns (namespace qualified-name)
+              type (var->type meta)]]
+    (candidate-data name ns qualified-name type)))
+
+(defn ns-var-candidates
+  "Returns candidate data for all vars defined in ns."
+  [env ns]
+  (var-candidates (a/ns-vars env ns)))
+
+(defn core-var-candidates
+  "Returns candidate data for all cljs.core vars visible in context-ns."
+  [env context-ns]
+  (var-candidates (a/core-vars env context-ns)))
+
+(defn macro-candidates
+  [macros]
+  (for [[name var] macros
+        :let [var-meta (meta var)
+              ns (ns-name (:ns var-meta))
+              qualified-name (:name var-meta)]]
+    (candidate-data name ns qualified-name :macro)))
+
+(defn core-macro-candidates
+  [env ns]
+  "Returns candidate data for all cljs.core macros visible in ns."
+  (macro-candidates (a/core-macros env ns)))
+
+(defn import-candidates
+  "Returns candidate data for all imports in context-ns."
+  [env context-ns]
+  (flatten
+   (for [[import qualified-name] (a/imports env context-ns)]
+     [(candidate-data import qualified-name qualified-name :import)
+      (candidate-data qualified-name qualified-name qualified-name :import)])))
+
+(defn unscoped-candidates
+  "Returns all non-namespace-qualified potential candidates in context-ns."
+  [env context-ns]
+  (concat special-form-candidates
+          (all-ns-candidates env)
+          (ns-candidates env context-ns)
+          (macro-ns-candidates env context-ns)
+          (referred-var-candidates env context-ns)
+          (referred-macro-candidates env context-ns)
+          (ns-var-candidates env context-ns)
+          (core-var-candidates env context-ns)
+          (core-macro-candidates env context-ns)
+          (import-candidates env context-ns)))
 
-(defn ns-completions
-  "Returns a list of public vars in the given namespace."
-  ([env ns] (keys (a/public-vars env ns)))
-  ([env ns prefix] (prefix-completions prefix (ns-completions env ns))))
+(defn- prefix-candidate
+  [prefix candidate-data]
+  (let [candidate (:candidate candidate-data)
+        prefixed-candidate (str prefix "/" candidate)]
+    (assoc candidate-data :candidate prefixed-candidate)))
 
-(defn macro-ns-completions
-  "Returns a list of macro names in the given namespace."
-  ([ns] (keys (a/public-macros ns)))
-  ([ns prefix] (prefix-completions prefix (macro-ns-completions ns))))
+(defn- prefix-candidates
+  [prefix candidates]
+  (map #(prefix-candidate prefix %) candidates))
 
 (defn- scope->ns
   [env scope context-ns]
@@ -33,41 +141,78 @@
     scope
     (a/to-macro-ns env scope context-ns)))
 
-(defn scoped-completions
+(defn ns-public-var-candidates
+  "Returns candidate data for all public vars defined in ns."
+  [env ns]
+  (var-candidates (a/public-vars env ns)))
+
+(defn ns-macro-candidates
+  "Returns candidate data for all macros defined in ns."
+  [env ns]
+  (macro-candidates (a/public-macros ns)))
+
+(defn scoped-candidates
+  "Returns all candidates for the namespace of sym. Sym must be
+  namespace-qualified. Macro candidates are included if the namespace has its
+  macros required in context-ns."
   [env sym context-ns]
   (let [scope (symbol (namespace sym))
-        ns (scope->ns scope)
-        macro-ns (scope->macro-ns scope)]
-    (concat (ns-completions env ns scope)
-            (macro-ns-completions macro-ns scope))))
+        ns (scope->ns env scope context-ns)
+        macro-ns (scope->macro-ns env scope context-ns)]
+    (mapcat #(prefix-candidates scope %)
+            [(ns-public-var-candidates env ns)
+             (ns-macro-candidates env macro-ns)])))
 
-(defn unscoped-completions
-  [env context-ns]
-  (concat special-forms
-          (keys (a/all-ns env))
-          (keys (a/ns-aliases env context-ns))
-          (keys (a/macro-ns-aliases env context-ns))
-          (keys (a/referred-vars env context-ns))
-          (keys (a/referred-macros env context-ns))
-          (keys (a/ns-vars env context-ns true))
-          (keys (a/core-macros env context-ns))
-          (keys (a/imports env context-ns))
-          (vals (a/imports env context-ns))))
-
-(defn potential-completions
+(defn potential-candidates
+  "Returns all candidates for sym. If sym is namespace-qualified, the candidates
+  for that namespace will be returned (including macros if the namespace has its
+  macros required in context-ns). Otherwise, all non-namespace-qualified
+  candidates for context-ns will be returned."
   [env sym context-ns]
   (if (namespace sym)
-    (scoped-completions env sym context-ns)
-    (unscoped-completions env context-ns)))
+    (scoped-candidates env sym context-ns)
+    (unscoped-candidates env context-ns)))
+
+(def ^:private type-ranking
+  [:special
+   :ns
+   :fn
+   :protocol-fn
+   :record
+   :type
+   :protocol
+   :var
+   :macro
+   :import])
+
+(defn- candidate-rank
+  [candidate types]
+  (.indexOf (vec types) (:type candidate)))
+
+(defn- distinct-candidates
+  "Filters candidates to have only one entry for each value of :candidate. If
+  multiple such entries do exist, the one with the earliest appearing value
+  of :type in types will be used."
+  [candidates types]
+  (let [grouped-candidates (group-by :candidate candidates)]
+    (for [[candidate group] grouped-candidates]
+      (first (sort-by #(candidate-rank % types) group)))))
+
+(defn- candidate-match?
+  [candidate prefix]
+  (.startsWith ^String (:candidate candidate) (str prefix)))
 
 (defn completions
-  "Return a sequence of matching completions given current namespace and a prefix string"
+  "Returns a sequence of matching completions given current namespace and a
+  prefix string."
   ([env prefix] (completions env prefix nil))
   ([env prefix context-ns]
-   (->> (potential-completions env (u/as-sym prefix) (u/as-sym context-ns))
-        distinct
-        (map str)
-        (filter #(.startsWith % prefix))
-        sort)))
+   (let [prefix (u/as-sym prefix)
+         context-ns (u/as-sym context-ns)
+         candidates (potential-candidates env prefix context-ns)]
+     (as-> candidates $
+       (distinct-candidates $ type-ranking)
+       (filter #(candidate-match? % prefix) $)
+       (sort-by :candidate $)))))
 
 

src/cljs_tooling/info.clj

@@ -88,7 +88,10 @@
      [macro (get (a/referred-macros env context-ns) sym)] (format-macro (-> macro find-var meta))
 
      ;; var in ns
-     [context-var (get (a/ns-vars env context-ns true) sym)] (format-var context-ns context-var)
+     [context-var (get (a/ns-vars env context-ns) sym)] (format-var context-ns context-var)
+
+     ;; var in cljs.core
+     [var (get (a/core-vars env context-ns) sym)] (format-var context-ns var)
 
      ;; macro in cljs.core
      [macro (get (a/public-macros 'cljs.core) sym)] (format-macro (meta macro))

src/cljs_tooling/util/analysis.clj

@@ -82,18 +82,28 @@
   [var]
   ((complement :anonymous) (val var)))
 
-(defn public-vars
-  "Returns a list of the public vars declared in the ns."
-  [env ns]
-  (let [vars (:defs (find-ns env ns))]
-    (into {} (filter (every-pred public? named?) vars))))
-
 (defn- macro?
   [var]
   (-> (val var)
       meta
       :macro))
 
+(defn ns-vars
+  "Returns a list of the vars declared in the ns."
+  [env ns]
+  (->> (find-ns env ns)
+       :defs
+       (filter named?)
+       (into {})))
+
+(defn public-vars
+  "Returns a list of the public vars declared in the ns."
+  [env ns]
+  (->> (find-ns env ns)
+       :defs
+       (filter (every-pred named? public?))
+       (into {})))
+
 (defn public-macros
   "Returns a list of the public macros declared in the ns."
   [ns]
@@ -109,16 +119,6 @@
         excludes (:excludes (find-ns env ns))]
     (apply dissoc vars excludes)))
 
-(defn ns-vars
-  "Returns a list of vars visible to the ns."
-  ([env ns] (ns-vars env ns false))
-  ([env ns include-core?]
-   (merge (->> (find-ns env ns)
-               :defs
-               (filter named?)
-               (into {}))
-          (if include-core? (core-vars env ns)))))
-
 (defn core-macros
   "Returns a list of cljs.core macros visible to the ns."
   [env ns]

test-resources/test_ns.cljs

@@ -3,3 +3,5 @@
   (:require [cljs.core.async :refer [sliding-buffer]]
             [clojure.string]
             [om.core]))
+
+(defrecord TestRecord [a b c])