     ast))
 
 
-(defn load-macros [env {:keys [op name] :as ast}]
+(defn load-macros [_ {:keys [op name] :as ast}]
   (if (or (not= :ns op)
           (not (-> name meta :load-macros)))
     ast

                                         (conj m var-name)
                                         m))
                                     #{}))]
          ;; this is sort of ugly, but the compiler env does not store the result of a pass, only the parse
          (swap! env/*compiler* assoc-in [::ana/namespaces name :macros] macros)
          (assoc ast :macros macros)
          ))))

(defn infer-macro-require [env {:keys [op requires name] :as ast}]
  (if (or (not= :ns op)
          (empty? requires))
    ast

              (let [macros (get-in @env/*compiler* [::ana/namespaces used-ns :macros])]
                (if (contains? macros used-name)
                  (let [update-fn (fn [current]
                                    (update-in current [:use-macros] merge {used-name used-ns}))]

                    (swap! env/*compiler* update-in [::ana/namespaces name] update-fn)
                    (update-fn ast))
