CLJS-3276 Support macros that expand to require statements

Support this pattern:

   (ns foo.bar
     (:require-macros [foo.baz :refer [macro-that-expands-to-require]]))
   (macro-that-expands-to-require)

To do so we adapt ana/parse-ns to look for consecutive :ns/:ns* ops (ns and
require forms), until a non :ns/:ns* form is encountered. The information of
consecutive forms are merged so the ns-info that parse-ns returns is complete.
This was already happening for :ns* ops (require forms), but not for :ns forms.

This means that parse-ns analyzes/parses at least one form beyond the last
ns/require form, but this can be problematic since this modifies the compiler
env. For instance if the form after ns is a (def ^const ...) then analyzing this
twice will cause an error. Hence the check to only analyze macro forms or
ns/require forms. This should also help in general to avoid unnecessary work.

To make sure the invocation is seen as a macro, and is able to be expanded, we
need to keep track of namespace information in the env across multiple :ns/:ns*
ops. When encountering a macro invocation we load the macro ns on the fly by
invoking the ns-side-effects analyzer pass directly. After this we can call
analyze on the form.

Author: plexus

src/main/clojure/cljs/analyzer.cljc

@@ -4329,6 +4329,19 @@
                     (.lastIndexOf full-name "."))]
          (symbol (str "cljs.user." name (util/content-sha full-name 7)))))))
 
+#?(:clj
+   (defn macro-call? [form env]
+     (when (and (seq? form) (seq form) (and (symbol? (first form))))
+       (let [sym (first form)
+             nstr (namespace sym)]
+         (or (and (some? nstr)
+                  (some? (gets env :ns :require-macros (symbol nstr))))
+             (some? (gets env :ns :rename-macros sym))
+             (some? (gets env :ns :use-macros sym)))))))
+
+#?(:clj
+   (declare ns-side-effects macroexpand-1))
+
 #?(:clj
    (defn ^:dynamic parse-ns
      "Helper for parsing only the essential namespace information from a
@@ -4354,6 +4367,9 @@
               (binding [env/*compiler* (if (false? (:restore opts))
                                          env/*compiler*
                                          (atom @env/*compiler*))
+                        *file-defs* nil
+                        #?@(:clj [*unchecked-if* false
+                                  *unchecked-arrays* false])
                         *cljs-ns* 'cljs.user
                         *cljs-file* src
                         *macro-infer*
@@ -4370,7 +4386,8 @@
                           false)]
                 (let [rdr (when-not (sequential? src) (io/reader src))]
                   (try
-                    (loop [forms (if rdr
+                    (loop [env (empty-env)
+                           forms (if rdr
                                    (forms-seq* rdr (source-path src))
                                    src)
                            ret (merge
@@ -4385,43 +4402,54 @@
                                    {:lines (with-open [reader (io/reader dest)]
                                              (-> reader line-seq count))}))]
                       (if (seq forms)
-                        (let [env (empty-env)
-                              ast (no-warn (analyze env (first forms) nil opts))]
+                        (let [form (first forms)
+                              macro? (macro-call? form env)
+                              env (if macro?
+                                    (binding [*load-macros* true]
+                                      (assoc (:env (ns-side-effects env (:ast ret) opts)) :ns (:ns env)))
+                                    env)
+                              ast (when (or macro? (and (seq? form) ('#{ns ns* require use require-macros} (first form))))
+                                    (no-warn (analyze env form nil opts)))
+                              env (assoc (:env ast) :ns (:ns env))]
                           (cond
                             (= :ns (:op ast))
                             (let [ns-name (:name ast)
                                   ns-name (if (and (= 'cljs.core ns-name)
                                                    (= "cljc" (util/ext src)))
                                             'cljs.core$macros
                                             ns-name)
-                                  deps (merge (:uses ast) (:requires ast))]
-                              (merge
-                                {:ns           (or ns-name 'cljs.user)
-                                 :provides     [ns-name]
-                                 :requires     (if (= 'cljs.core ns-name)
-                                                 (set (vals deps))
-                                                 (cond-> (conj (set (vals deps)) 'cljs.core)
-                                                   (get-in @env/*compiler* [:options :emit-constants])
-                                                   (conj constants-ns-sym)))
-                                 :file         dest
-                                 :source-file  (when rdr src)
-                                 :source-forms (when-not rdr src)
-                                 :ast          ast
-                                 :macros-ns    (or (:macros-ns opts)
-                                                   (= 'cljs.core$macros ns-name))}
-                                (when (and dest (.exists ^File dest))
-                                  {:lines (with-open [reader (io/reader dest)]
-                                            (-> reader line-seq count))})))
+                                  deps (merge (:uses ast) (:requires ast))
+                                  env (assoc (:env ast) :ns (dissoc ast :env))]
+                              (recur env
+                                     (rest forms)
+                                     (cond->
+                                         {:ns           (or ns-name 'cljs.user)
+                                          :provides     [ns-name]
+                                          :requires     (if (= 'cljs.core ns-name)
+                                                          (set (vals deps))
+                                                          (cond-> (conj (set (vals deps)) 'cljs.core)
+                                                            (get-in @env/*compiler* [:options :emit-constants])
+                                                            (conj constants-ns-sym)))
+                                          :file         dest
+                                          :source-file  (when rdr src)
+                                          :source-forms (when-not rdr src)
+                                          :ast          ast
+                                          :macros-ns    (or (:macros-ns opts)
+                                                            (= 'cljs.core$macros ns-name))}
+                                       (and dest (.exists ^File dest))
+                                       (assoc :lines (with-open [reader (io/reader dest)]
+                                                       (-> reader line-seq count))))))
 
                             (= :ns* (:op ast))
                             (let [deps (merge (:uses ast) (:requires ast))]
-                              (recur (rest forms)
-                                (cond-> (update-in ret [:requires] into (set (vals deps)))
-                                  ;; we need to defer generating the user namespace
-                                  ;; until we actually need or it will break when
-                                  ;; `src` is a sequence of forms - António Monteiro
-                                  (not (:ns ret))
-                                  (assoc :ns (gen-user-ns src) :provides [(gen-user-ns src)]))))
+                              (recur (:env ast)
+                                     (rest forms)
+                                     (cond-> (update-in ret [:requires] into (set (vals deps)))
+                                       ;; we need to defer generating the user namespace
+                                       ;; until we actually need or it will break when
+                                       ;; `src` is a sequence of forms - António Monteiro
+                                       (not (:ns ret))
+                                       (assoc :ns (gen-user-ns src) :provides [(gen-user-ns src)]))))
 
                             :else ret))
                         ret))

src/test/cljs_build/cljs_3276/foo.cljs

@@ -0,0 +1 @@
+(ns cljs-3276.foo)

src/test/cljs_build/cljs_3276/macros.clj

@@ -0,0 +1,4 @@
+(ns cljs-3276.macros)
+
+(defmacro macro-that-requires []
+  `(require 'cljs-3276.foo))

src/test/clojure/cljs/analyzer_tests.clj

@@ -1492,3 +1492,13 @@
         '[(ns test.foo
             (:import goog))]))
     (is (= {} (get-in @cenv [::ana/namespaces 'test.foo :imports])))))
+
+(deftest test-cljs-3276-require-from-macro
+  (let [cenv (env/default-compiler-env)]
+    (env/with-compiler-env cenv
+      (ana/analyze-form-seq
+       '[(ns test.foo
+           (:require-macros [cljs-3276.macros :refer [macro-that-requires]]))
+         (macro-that-requires)]))
+    (is (= '{cljs-3276.foo cljs-3276.foo} (get-in @cenv [::ana/namespaces 'test.foo :requires])))
+    (is (contains? (get @cenv ::ana/namespaces) 'cljs-3276.foo))))