CLJS-1492: Warn when using :optimisations instead of :optimizations

Detect when an unknown compiler or REPL option is passed by comparing
against explicitly-maintained set of all known options. When an unknown
option is passed, find a known one with minimum Levenshtein distance
from the unknown option (within a threshold), and warn and suggest
correct option name.

Author: mfikes

src/main/clojure/cljs/build/api.clj

@@ -203,6 +203,9 @@
        env/*compiler*
        (env/default-compiler-env opts))))
   ([source opts compiler-env]
+   (doseq [[unknown-opt suggested-opt] (util/unknown-opts (set (keys opts)) closure/known-opts)]
+     (println (str "WARNING: Unknown compiler option '" unknown-opt "'."
+                (when suggested-opt (str " Did you mean '" suggested-opt "'?")))))
    (binding [ana/*cljs-warning-handlers* (:warning-handlers opts ana/*cljs-warning-handlers*)]
      (closure/build source opts compiler-env))))
 

src/main/clojure/cljs/closure.clj

@@ -160,6 +160,15 @@
    :unknown-defines DiagnosticGroups/UNKNOWN_DEFINES
    :visiblity DiagnosticGroups/VISIBILITY})
 
+(def known-opts
+  "Set of all known compiler options."
+  #{:anon-fn-naming-policy :asset-path :cache-analysis :closure-defines :closure-extra-annotations
+    :closure-warnings :compiler-stats :dump-core :elide-asserts :externs :foreign-libs
+    :hashbang :language-in :language-out :libs :main :modules :source-map-path :optimizations
+    :optimize-constants :output-dir :output-to :output-wrapper :parallel-build :preamble
+    :pretty-print :print-input-delimiter :pseudo-names :recompile-dependents :source-map
+    :source-map-inline :source-map-timestamp :static-fns :target :verbose :warnings})
+
 (defn set-options
   "TODO: Add any other options that we would like to support."
   [opts ^CompilerOptions compiler-options]

src/main/clojure/cljs/repl.cljc

@@ -10,6 +10,7 @@
   (:refer-clojure :exclude [load-file])
   (:require [clojure.java.io :as io]
             [clojure.string :as string]
+            [clojure.set :as set]
             [clojure.data.json :as json]
             [clojure.tools.reader :as reader]
             [clojure.tools.reader.reader-types :as readers]
@@ -36,6 +37,11 @@
 (def ^:dynamic *cljs-verbose* false)
 (def ^:dynamic *repl-opts* nil)
 
+(def known-repl-opts
+  "Set of all known REPL options."
+  #{:analyze-path :caught :def-emits-var :flush :need-prompt :print :print-no-newline :prompt :read
+    :reader :repl-verbose :watch :watch-fn})
+
 (defmacro err-out [& body]
   `(binding [*out* *err*]
      ~@body))
@@ -773,6 +779,9 @@
                                   [cljs.pprint :refer [pprint] :refer-macros [pp]]]
                   bind-err true}
              :as opts}]
+  (doseq [[unknown-opt suggested-opt] (util/unknown-opts (set (keys opts)) (set/union known-repl-opts cljsc/known-opts))]
+    (println (str  "WARNING: Unknown option '" unknown-opt "'."
+               (when suggested-opt (str " Did you mean '" suggested-opt "'?")))))
   (let [repl-opts (-repl-options repl-env)
         repl-requires (into repl-requires (:repl-requires repl-opts))
         {:keys [analyze-path repl-verbose warn-on-undeclared special-fns static-fns] :as opts

src/main/clojure/cljs/util.cljc

@@ -208,3 +208,42 @@
 
 (defn boolean? [x]
   (or (true? x) (false? x)))
+
+(defn levenshtein-distance
+  "The the minimum number of single-element edits needed to
+  transform s in to t."
+  [s t]
+  (let [f (fn [f s t]
+            (cond
+              (empty? s) (count t)
+              (empty? t) (count s)
+              :else (let [cost (if (= (first s) (first t))
+                                 0
+                                 1)]
+                      (min (inc (f f (rest s) t))
+                        (inc (f f s (rest t)))
+                        (+ cost (f f (rest s) (rest t)))))))
+        g (memoize f)]
+    (g g s t)))
+
+(defn suggestion
+  "Provides a best suggestion for an unknown, taken from knowns,
+  minimizing the Levenshtein distance, returning nil if threshold
+  cannot be satisfied."
+  [threshold unknown knowns]
+  (let [distance     (partial levenshtein-distance unknown)
+        closest      (apply min-key distance knowns)
+        closest-dist (distance closest)]
+    (when (<= closest-dist threshold)
+      closest)))
+
+(defn unknown-opts
+  "Takes a set of passed opt keys and known opt keys and for each
+  unknown opt key returns a vector of the key and its (potentially
+  nil) suggestion."
+  [passed knowns]
+  {:pre [(set? passed) (set? knowns)]}
+  (for [unknown (set/difference passed knowns)]
+    [unknown (some-> (suggestion 3 (str unknown) (map str knowns))
+               (subs 1)
+               keyword)]))

src/test/clojure/cljs/util_tests.clj

@@ -0,0 +1,20 @@
+(ns cljs.util-tests
+  (:require [cljs.util :as util])
+  (:use clojure.test))
+
+(deftest test-levenshtein-distance
+  (testing "levenshtein-distance"
+    (is (= 0 (util/levenshtein-distance "abc" "abc")))
+    (is (= 1 (util/levenshtein-distance "abc" "abcd")))
+    (is (= 1 (util/levenshtein-distance "abcd" "abc")))
+    (is (= 3 (util/levenshtein-distance "kitten" "sitting")))))
+
+(deftest test-suggestion
+  (testing "suggestion"
+    (is (= ":optimization" (util/suggestion 3 ":optimization" [":optimization" ":static-fns"])))))
+
+(deftest test-unknown-opts
+  (testing "unknown-opts"
+    (is (= [[:bogus nil]
+            [:optimisations :optimizations]]
+          (sort (util/unknown-opts #{:optimisations :bogus} #{:optimizations :static-fns}))))))