performance/single-literal-merge: Add :dynamic style

Adds and defaults to `:dynamic`, which acts as `:single` or `:multiple` depending on the number of elements in the map literal. (See [#35](#35).)

Author: NoahTheDuke

CHANGELOG.md

@@ -32,6 +32,7 @@ Update rules:
 - `lint/require-explicit-param-tags`: clean up docs.
 - `performance/into-transducer`: remove `cat` as it can't be used in the incorrect form.
 - `performance/into-transducer`: add configurable fn list with `:fn-0-arg` and `:fn-1-arg` (depending on how many arguments the fn accepts).
+- `performance/single-literal-merge`: adds and defaults to `:dynamic`, which acts as `:single` or `:multiple` depending on the number of elements in the map literal. (See [#35](https://github.com/NoahTheDuke/splint/issues/35).)
 
 Patterns:
 

resources/noahtheduke/splint/config/default.edn

@@ -439,10 +439,11 @@
  performance/single-literal-merge
  {:description "Prefer assoc over merge when merging a literal."
   :enabled false
-  :chosen-style :single
-  :supported-styles [:single :multiple]
+  :chosen-style :dynamic
+  :supported-styles [:single :multiple :dynamic]
   :added "1.11"
-  :updated "1.11"}
+  :updated "<<next>>"
+  :links ["https://bsless.github.io/code-smells"]}
 
  ;; Style Rules
 

src/noahtheduke/splint/rules/performance/into_transducer.clj

@@ -23,13 +23,13 @@
   ; avoid
   (into [] (map inc (range 100)))
 
-  ; avoid (with `:fn-names [cool-fn]`)
+  ; avoid (with `:fn-1-arg [cool-fn]`)
   (into [] (cool-fn inc (range 100)))
 
   ; prefer
   (into [] (map inc) (range 100))
 
-  ; prefer (with `:fn-names [cool-fn]`)
+  ; prefer (with `:fn-1-arg [cool-fn]`)
   (into [] (cool-fn inc) (range 100))
   "
   {:pattern '(into [?*args] (?trans ??f ?coll))

src/noahtheduke/splint/rules/performance/single_literal_merge.clj

@@ -26,6 +26,8 @@
 (defrule performance/single-literal-merge
   "`clojure.core/merge` is inherently slow. Its major benefit is handling nil values. If there is only a single object to merge in and it's a map literal, that benefit is doubly unused. Better to directly assoc the values in.
 
+  By default, this rule suggests alternatives based on how many elements are in the map literal: 4 or less will suggest as `:single`, more than 4 will suggest as `:multiple`. Either can be set in the config to enforce one or the other.
+
   @note
   If the chosen style is `:single` and `performance/assoc-many` is enabled, the style will be treated as `:multiple` to make the warnings consistent.
 
@@ -34,7 +36,7 @@
   ; avoid
   (merge m {:a 1 :b 2 :c 3})
 
-  ; prefer (chosen style :single (default))
+  ; prefer (chosen style :single)
   (assoc m :a 1 :b 2 :c 3)
 
   ; prefer (chosen style :multiple)
@@ -48,7 +50,11 @@
    :autocorrect true
    :on-match (fn [ctx rule form {:syms [?given ?literal]}]
                (when-let [?literal (not-empty ?literal)]
-                 (let [new-form (condp = (select-style ctx rule)
+                 (let [new-form (case (select-style ctx rule)
                                   :single (single-assoc ?given ?literal)
-                                  :multiple (multi-assoc ?given ?literal))]
+                                  :multiple (multi-assoc ?given ?literal)
+                                  ;; default to dynamic
+                                  #_:dynamic (if (< 4 (count ?literal))
+                                               (multi-assoc ?given ?literal)
+                                               (single-assoc ?given ?literal)))]
                    (->diagnostic ctx rule form {:replace-form new-form}))))})

test/noahtheduke/splint/rules/performance/single_literal_merge_test.clj

@@ -4,42 +4,67 @@
 
 (ns noahtheduke.splint.rules.performance.single-literal-merge-test
   (:require
-   [lazytest.core :refer [defdescribe it]]
+   [lazytest.core :refer [defdescribe it describe]]
    [noahtheduke.splint.test-helpers :refer [expect-match single-rule-config]]))
 
 (set! *warn-on-reflection* true)
 
 (def rule-name 'performance/single-literal-merge)
 
 (defdescribe single-literal-merge-test
-  (it "flattens given map"
-    (expect-match
-      [{:rule-name 'performance/single-literal-merge
-        :form '(merge m {:a 1 :b 2})
-        :message "Prefer assoc for merging literal maps"
-        :alt '(assoc m :a 1 :b 2)}]
-      "(merge m {:a 1 :b 2})"
-      (single-rule-config rule-name)))
+  (describe ":chosen-style :single"
+    (it "flattens given map"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a 1 :b 2})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(assoc m :a 1 :b 2)}]
+        "(merge m {:a 1 :b 2})"
+        (single-rule-config rule-name  {:chosen-style :single})))
 
-  (it "works on nil"
-    (expect-match
-      [{:rule-name 'performance/single-literal-merge
-        :form '(merge nil {:a 1 :b 2})
-        :message "Prefer assoc for merging literal maps"
-        :alt '(assoc nil :a 1 :b 2)}]
-      "(merge nil {:a 1 :b 2})"
-      (single-rule-config rule-name)))
+    (it "works on nil"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge nil {:a 1 :b 2})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(assoc nil :a 1 :b 2)}]
+        "(merge nil {:a 1 :b 2})"
+        (single-rule-config rule-name {:chosen-style :single}))))
 
-  (it "respects :chosen-style :multiple"
-    (expect-match
-      [{:rule-name 'performance/single-literal-merge
-        :form '(merge m {:a 1 :b 2})
-        :message "Prefer assoc for merging literal maps"
-        :alt '(-> m
-                  (assoc :a 1)
-                  (assoc :b 2))}]
-      "(merge m {:a 1 :b 2})"
-      (single-rule-config rule-name {:chosen-style :multiple})))
+  (describe ":chosen-style :multiple"
+    (it "works as expected"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a 1 :b 2})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(-> m
+                    (assoc :a 1)
+                    (assoc :b 2))}]
+        "(merge m {:a 1 :b 2})"
+        (single-rule-config rule-name {:chosen-style :multiple}))))
+
+  (describe ":chosen-style :dynamic"
+    (it "acts as :single if map literal is small"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a 1 :b 2})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(assoc m :a 1 :b 2)}]
+        "(merge m {:a 1 :b 2})"
+        (single-rule-config rule-name {:chosen-style :dynamic})))
+    (it "acts as :multiple if map literal is large"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a :b :c :d :e :f :g :h :i :j})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(-> m
+                    (assoc :a :b)
+                    (assoc :c :d)
+                    (assoc :e :f)
+                    (assoc :g :h)
+                    (assoc :i :j))}]
+        "(merge m {:a :b :c :d :e :f :g :h :i :j})"
+        (single-rule-config rule-name {:chosen-style :dynamic}))))
 
   (it "it respects performance/assoc-many"
     (expect-match
@@ -50,7 +75,31 @@
                   (assoc :a 1)
                   (assoc :b 2))}]
       "(merge m {:a 1 :b 2})"
-      (update (single-rule-config rule-name) 'performance/assoc-many assoc :enabled true)))
+      (update (single-rule-config rule-name {:chosen-style :single})
+              'performance/assoc-many assoc :enabled true)))
+
+  (describe ":chosen-style defaults to :dynamic"
+    (it "acts as :single if map literal is small"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a 1 :b 2})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(assoc m :a 1 :b 2)}]
+        "(merge m {:a 1 :b 2})"
+        (single-rule-config rule-name {:chosen-style nil})))
+    (it "acts as :multiple if map literal is large"
+      (expect-match
+        [{:rule-name 'performance/single-literal-merge
+          :form '(merge m {:a :b :c :d :e :f :g :h :i :j})
+          :message "Prefer assoc for merging literal maps"
+          :alt '(-> m
+                    (assoc :a :b)
+                    (assoc :c :d)
+                    (assoc :e :f)
+                    (assoc :g :h)
+                    (assoc :i :j))}]
+        "(merge m {:a :b :c :d :e :f :g :h :i :j})"
+        (single-rule-config rule-name {:chosen-style nil}))))
 
   (it "keeps the order in the alt"
     (expect-match
@@ -67,7 +116,7 @@
         :message "Prefer assoc for merging literal maps"
         :alt '(assoc a :a :b :c :d :e :f :g :h :i :j :k :l :m :n :o :p :q :r :s :t :u :v :w :x :y :z)}]
       "(merge a {:a :b :c :d :e :f :g :h :i :j :k :l :m :n :o :p :q :r :s :t :u :v :w :x :y :z})"
-      (single-rule-config rule-name)))
+      (single-rule-config rule-name {:chosen-style :single})))
 
   (it "ignores multiple maps"
     (expect-match