Implement write-class and wire it into eval, load

This commit implements a write-class function (extracted from Oxcart)
and wires it into the eval and load implementations as appropriate
creating :compile-files kw options on both functions the default value
for which is false.

Fixes TEMJVM-15

Default to false iff *compile-files* isn't bound

This changes the behavior of the :compile-files keyword option so that
rather than defaulting to false if unset, if *compile-files* is bound
that value will be propigated. Only if :compile-files is not provided
and *compile-files* is unbound will the default value of false occur.

Author: arrdem

src/main/clojure/clojure/tools/emitter/jvm.clj

@@ -31,11 +31,29 @@
             [clojure.tools.reader.reader-types :as readers])
   (:import (clojure.lang IFn DynamicClassLoader Atom)))
 
+(defn write-class
+  "(λ ClassName → Bytecode) → Nil
+
+  Writes the given bytecode to a file named by the ClassName and
+  *compile-path*. Requires that *compile-path* be set. Returns Nil."
+  [name bytecode]
+  {:pre [(bound? #'clojure.core/*compile-path*)]}
+  (let [path (str *compile-path* "/" name ".class")
+        file (io/file path)]
+    (.mkdirs (io/file (.getParent file)))
+    (with-open [w (java.io.FileOutputStream. path)]
+      (.write w bytecode)))
+  nil)
+
 (defn compile-and-load
   ([class-ast]
      (compile-and-load class-ast (clojure.lang.RT/makeClassLoader)))
   ([{:keys [class-name] :as class-ast} class-loader]
-     (.defineClass ^DynamicClassLoader class-loader class-name (t/-compile class-ast) nil)))
+     (let [bytecode (t/-compile class-ast)]
+       (when (and (bound? #'clojure.core/*compile-files*)
+                  *compile-files*)
+         (write-class class-name bytecode))
+       (.defineClass ^DynamicClassLoader class-loader class-name bytecode nil))))
 
 
 (def passes (into (disj a/default-passes #'trim)
@@ -77,15 +95,27 @@
   :analyze-opts :- (Option analyze-options-map)
     An options map that will be passed to the analyzer. The keys which
     are significant in this map are documented in the t.a.jvm/analyze
-    docstring."
+    docstring.
+
+  :class-loader :- (Option ClassLoader)
+    An optional classloader into which compiled functions will be
+    injected. If not provided, a new Clojure classloader will be
+    used. If a class loader is provided here, one need not be provided
+    in eval-opts.
+
+  :compile-files :- (Option Bool)
+    Enables or disables writing classfiles for generated classes. False
+    by default."
 
   ([form]
      (eval form {}))
-  ([form {:keys [debug? emit-opts class-loader analyze-opts]
-          :or {debug?       false
-               emit-opts    {}
-               analyze-opts a/default-passes-opts
-               class-loader (clojure.lang.RT/makeClassLoader)}
+  ([form {:keys [debug? emit-opts class-loader analyze-opts compile-files]
+          :or {debug?        false
+               emit-opts     {}
+               analyze-opts  a/default-passes-opts
+               compile-files (if (bound? #'clojure.core/*compile-files*)
+                               *compile-files* false)
+               class-loader  (clojure.lang.RT/makeClassLoader)}
           :as options}]
      {:pre [(instance? DynamicClassLoader class-loader)]}
      (let [mform (binding [macroexpand-1 a/macroexpand-1]
@@ -98,7 +128,8 @@
            (doseq [expr statements]
              (eval expr options))
            (eval ret options))
-         (binding [a/run-passes run-passes]
+         (binding [a/run-passes    run-passes
+                   *compile-files* compile-files]
            (let [cs (-> (a/analyze `(^:once fn* [] ~mform) (a/empty-env) analyze-opts)
                       (e/emit-classes (merge {:debug? debug?} emit-opts)))
                  classes (mapv #(compile-and-load % class-loader) cs)]
@@ -130,14 +161,20 @@
     An optional classloader into which compiled functions will be
     injected. If not provided, a new Clojure classloader will be
     used. If a class loader is provided here, one need not be provided
-    in eval-opts."
+    in eval-opts.
+
+  :compile-files :- (Option Bool)
+    Enables or disables writing classfiles for generated classes. False
+    by default."
 
   ([res]
      (load res {}))
-  ([res {:keys [debug? eval-opts class-loader]
-         :or   {debug?       false
-                eval-opts    {}
-                class-loader (clojure.lang.RT/makeClassLoader)}
+  ([res {:keys [debug? eval-opts class-loader compile-files]
+         :or   {debug?        false
+                eval-opts     {}
+                compile-files (if (bound? #'clojure.core/*compile-files*)
+                                *compile-files* false)
+                class-loader  (clojure.lang.RT/makeClassLoader)}
          :as options}]
      (let [p      (str (apply str (replace {\. \/ \- \_} res)) ".clj")
            eof    (Object.)
@@ -146,13 +183,15 @@
                     (subs (str (root-directory (ns-name *ns*)) "/" p) 1))
            file   (-> p io/resource io/reader slurp)
            reader (readers/indexing-push-back-reader file 1 p)]
-       (binding [*ns*   *ns*
-                 *file* p]
+       (binding [*ns*            *ns*
+                 *file*          p
+                 *compile-files* compile-files]
          (loop []
            (let [form (r/read reader false eof)]
              (when (not= eof form)
                (eval form (merge eval-opts
                                  (when class-loader
-                                   {:class-loader class-loader})))
+                                   {:class-loader  class-loader
+                                    :compile-files compile-files})))
                (recur))))
          nil))))