[#434] fix :lint-as clojure.core/for (2)

corpus/lint_as_for.clj

@@ -2,10 +2,16 @@
   {:clj-kondo/config '{;; TODO: setting the level doesn't yet work in ns local
                        ;; configs, see #430, so we have to set it in our tests
                        :linters {:unresolved-symbol {:level :warning}}
-                       :lint-as {plumbing.core/for-map clojure.core/for}}})
+                       :lint-as {plumbing.core/for-map clojure.core/for
+                                 clojure.java.jdbc/with-db-transaction clojure.core/let}}})
 
 (require 'plumbing.core)
 
 (plumbing.core/for-map [[k v] {} :let [[v & _rst] v]] [k v])
 
 (for [[k v] {} :let [[v & _rst] v]] [k v])
+
+;; the fix for #434 does not result in a redundant let warning for:
+(require 'clojure.java.jdbc)
+(let [_a 1 d 2]
+  (clojure.java.jdbc/with-db-transaction [db d] db))

src/clj_kondo/impl/analyzer.clj

@@ -354,8 +354,9 @@
        (map #(extract-bindings ctx %))
        (reduce deep-merge {})))
 
-(defn analyze-let-like-bindings [ctx binding-vector call]
-  (let [for-like? (one-of call [for doseq])]
+(defn analyze-let-like-bindings [ctx binding-vector]
+  (let [resolved-as-clojure-var-name (:resolved-as-clojure-var-name ctx)
+        for-like? (one-of resolved-as-clojure-var-name [for doseq])]
     (loop [[binding value & rest-bindings] (-> binding-vector :children)
            bindings (:bindings ctx)
            arities (:arities ctx)
@@ -369,7 +370,7 @@
                    new-analyzed :analyzed
                    new-arities :arities}
                   (analyze-let-like-bindings
-                   (ctx-with-bindings ctx bindings) value call)]
+                   (ctx-with-bindings ctx bindings) value)]
               (recur rest-bindings
                      (merge bindings new-bindings)
                      (merge arities new-arities)
@@ -411,8 +412,9 @@
 
 (defn analyze-like-let
   [{:keys [:filename :callstack
-           :maybe-redundant-let?] :as ctx} expr call]
-  (let [let? (= 'let call)
+           :maybe-redundant-let?] :as ctx} expr]
+  (let [call (-> callstack first second)
+        let? (= 'let call)
         let-parent? (one-of (second callstack)
                             [[clojure.core let]
                              [cljs.core let]])
@@ -428,7 +430,7 @@
             (analyze-let-like-bindings
              (-> ctx
                  ;; prevent linting redundant let when using let in bindings
-                 (update :callstack #(cons [nil :let-bindings] %))) bv call)
+                 (update :callstack #(cons [nil :let-bindings] %))) bv)
             let-body (nnext (:children expr))
             single-child? (and let? (= 1 (count let-body)))]
         (lint-even-forms-bindings! ctx 'let bv)
@@ -551,14 +553,14 @@
     (namespace/reg-alias! ctx (:name ns) alias-sym ns-sym)
     (assoc-in ns [:qualify-ns alias-sym] ns-sym)))
 
-(defn analyze-loop [ctx expr call]
+(defn analyze-loop [ctx expr]
   (let [bv (-> expr :children second)]
     (when (and bv (= :vector (tag bv)))
       (let [arg-count (let [c (count (:children bv))]
                         (when (even? c)
                           (/ c 2)))]
         (analyze-like-let (assoc ctx
-                                 :recur-arity {:fixed-arity arg-count}) expr call)))))
+                                 :recur-arity {:fixed-arity arg-count}) expr)))))
 
 (defn analyze-recur [{:keys [:findings :filename :recur-arity] :as ctx} expr]
   (when-not (linter-disabled? ctx :invalid-arity)
@@ -884,6 +886,9 @@
         resolved-as-clojure-var-name
         (when (one-of resolved-as-namespace [clojure.core cljs.core])
           resolved-as-name)
+        ctx (if resolved-as-clojure-var-name
+              (assoc ctx :resolved-as-clojure-var-name resolved-as-clojure-var-name)
+              ctx)
         analyzed
         (case resolved-as-clojure-var-name
           ns
@@ -921,7 +926,7 @@
                                 (ctx-with-linter-disabled :invalid-arity)
                                 (ctx-with-linter-disabled :unresolved-symbol)) expr)
           (let let* for doseq dotimes with-open)
-          (analyze-like-let ctx expr resolved-as-clojure-var-name)
+          (analyze-like-let ctx expr)
           letfn
           (analyze-letfn ctx expr)
           (if-let if-some when-let when-some when-first)
@@ -933,7 +938,7 @@
           case
           (analyze-case ctx expr)
           loop
-          (analyze-loop ctx expr 'loop)
+          (analyze-loop ctx expr)
           recur
           (analyze-recur ctx expr)
           quote nil