Merge pull request #15 from cichli/completion-metadata

Completion metadata

Author: gtrak

src/cljs_tooling/complete.clj

@@ -3,72 +3,193 @@
   (:require [cljs-tooling.util.analysis :as a]
             [cljs-tooling.util.misc :as u]))
 
-;;; TODO
-(defn ns-classes
-  "Returns a list of potential class name completions for a given namespace"
-  [env ns]
+(defn- candidate-data
+  "Returns a map of candidate data for the given arguments."
+  [candidate ns type]
+  {:candidate (name candidate)
+   :ns (symbol ns)
+   :type type})
 
-  ;;(map name (keys (ns-imports ns)))
-  )
+(defn- var->type
+  "Returns the candidate type corresponding to the given metadata map."
+  [var]
+  (condp #(get %2 %1) var
+    :protocol :protocol-function
+    :fn-var :function
+    :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]
+    (candidate-data form 'cljs.core :special-form)))
+
+(defn all-ns-candidates
+  "Returns candidate data for all namespaces in the environment."
+  [env]
+  (for [[ns _] (a/all-ns env)]
+    (candidate-data ns ns :namespace)))
+
+(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 :namespace)))
+
+(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 :namespace)))
+
+(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 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 :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 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))]]
+    (candidate-data name ns :macro)))
 
-(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 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 :import)
+      (candidate-data 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- prefix-candidate
+  [prefix candidate-data]
+  (let [candidate (:candidate candidate-data)
+        prefixed-candidate (str prefix "/" candidate)]
+    (assoc candidate-data :candidate prefixed-candidate)))
+
+(defn- prefix-candidates
+  [prefix candidates]
+  (map #(prefix-candidate prefix %) candidates))
+
+(defn- scope->ns
+  [env scope context-ns]
+  (if (a/find-ns env scope)
+    scope
+    (a/to-ns env scope context-ns)))
 
-(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- scope->macro-ns
+  [env scope context-ns]
+  (if (= scope 'cljs.core)
+    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 (if (a/find-ns env scope)
-             scope
-             (a/to-ns env scope context-ns))
-        macro-ns (if (= scope 'cljs.core)
-                   scope
-                   (a/to-macro-ns env scope context-ns))]
-    (concat (ns-completions env ns scope)
-            (macro-ns-completions macro-ns scope))))
-
-(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))
-          (ns-classes env context-ns)))
-
-(defn potential-completions
+        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 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)))
+
+(defn- distinct-candidates
+  "Filters candidates to have only one entry for each value of :candidate. If
+  multiple such entries do exist, the first occurrence is used."
+  [candidates]
+  (map first (vals (group-by :candidate candidates))))
+
+(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 candidate data for completions matching the given
+  prefix string and (optionally) the current namespace."
   ([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)]
+     (->> (potential-candidates env prefix context-ns)
+          distinct-candidates
+          (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

@@ -2,7 +2,6 @@
   (:require [cljs-tooling.util.misc :as u])
   (:refer-clojure :exclude [find-ns find-var all-ns ns-aliases]))
 
-
 (def NSES :cljs.analyzer/namespaces)
 
 (defn all-ns
@@ -23,11 +22,20 @@
 
 ;; Code adapted from clojure-complete (http://github.com/ninjudd/clojure-complete)
 
+(defn imports
+  "Returns a map of [import-name] to [ns-qualified-import-name] for all imports
+  in the given namespace."
+  [env ns]
+  (:imports (find-ns env ns)))
 
 (defn ns-aliases
   "Returns a map of [ns-name-or-alias] to [ns-name] for the given namespace."
   [env ns]
-  (:requires (find-ns env ns)))
+  (let [imports (imports env ns)]
+    (->> (find-ns env ns)
+         :requires
+         (filter #(not (contains? imports (key %))))
+         (into {}))))
 
 (defn macro-ns-aliases
   "Returns a map of [macro-ns-name-or-alias] to [macro-ns-name] for the given namespace."
@@ -54,12 +62,6 @@
        :use-macros
        expand-refer-map))
 
-(defn imports
-  "Returns a map of [import-name] to [ns-qualified-import-name] for all imports
-  in the given namespace."
-  [env ns]
-  (:imports (find-ns env ns)))
-
 (defn to-ns
   "If sym is an alias to, or the name of, a namespace referred to in ns, returns
   the name of the namespace; else returns nil."
@@ -80,22 +82,32 @@
   [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]
-  (if (and ns (clojure.core/find-ns ns))
+  (when (and ns (clojure.core/find-ns ns))
     (->> (ns-publics ns)
          (filter macro?)
          (into {}))))
@@ -107,16 +119,6 @@
         excludes (:excludes (find-ns env ns))]
     (apply dissoc vars excludes)))
 
-(defn ns-vars
-  "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])