new :seq-emit-fn and map-style ops

Author: jgpc42

CHANGELOG.md

@@ -1,11 +1,12 @@
-## 0.5.5-SNAPSHOT (20XX-XX-XX)
+## 0.6.0-SNAPSHOT (20XX-XX-XX)
 
-* Upgrade to [ASM 9.7.1][asm]
+* Upgrade to [ASM 9.8][asm]
 * Explicit support for Clojure 1.12
 * Allow creating class names with no package (remove auto ns prefixing)
 * Add support for custom index objects via the `LocalIndex` protocol
 * Generate default constructor for :abstract classes too if one not provided
 * Support passing parameter and return types separately when defining methods
+* Experimental new map compilation facilitated by `:seq-emit-fn`.
 
 ## 0.5.4 (2022-04-14)
 

deps.edn

@@ -1,2 +1,2 @@
 {:deps
- {org.ow2.asm/asm {:mvn/version "9.7.1"}}}
+ {org.ow2.asm/asm {:mvn/version "9.8"}}}

project.clj

@@ -3,7 +3,7 @@
        :deps (mapv #(vector (% 0) (:mvn/version (% 1))))
        (into '[[org.clojure/clojure "1.8.0"]])))
 
-(defproject insn "0.5.5-SNAPSHOT"
+(defproject insn "0.6.0-SNAPSHOT"
   :description "Functional JVM bytecode generation for Clojure."
   :url "https://github.com/jgpc42/insn"
   :license {:name "Eclipse Public License"

src/insn/core.clj

@@ -69,6 +69,13 @@
 
     :debug        string of arbitrary debug information - optional.
 
+    :seq-emit-fn  fn to call with each bytecode seq. This is an advanced
+                  option and, if present, will be passed both the ASM
+                  MethodVisitor and the raw (possibly nested) :emit op
+                  seq for each method. Can be used to support new op
+                  data types. For example, the `insn.op-map/emit-seq` fn
+                  can be used to enable map-style op sequences.
+
   Each field and method can also be given :annotations and a :signature
   as per above.
 
@@ -192,13 +199,14 @@
                     {:name :init
                      :emit [[:aload 0]
                             [:invokespecial :super :init [:void]]
-                            [:return]]}))]
+                            [:return]]}))
+        seq-emit (:seq-emit-fn t op/emit-seq)]
     (binding [util/*this* this
               util/*super* super]
       (doseq [f (:fields t)]
         (visit-field cv f))
       (doseq [m (:methods t)]
-        (visit-method cv m))
+        (visit-method cv m seq-emit))
       (doto cv
         (ann/visit (:annotations t))
         .visitEnd))
@@ -217,7 +225,7 @@
     (ann/visit fv (:annotations f))
     (.visitEnd fv)))
 
-(defn- visit-method [^ClassVisitor cv m]
+(defn- visit-method [^ClassVisitor cv m seq-emit]
   (let [mname (util/method-name (:name m))
         clinit? (= mname "<clinit>")
         init? (= mname "<init>")
@@ -245,7 +253,9 @@
              (.visitCode))
         emit (or (:emit m) (:bytecode m))]
     (binding [util/*labels* (atom {})]
-      (emit mv))
+      (if (fn? emit)
+        (emit mv)
+        (seq-emit mv emit)))
     (ann/visit mv (:annotations m))
     (doseq [[i anns] (or (:parameter-annotations m) (:param-annotations m))]
       (ann/visit mv i anns))

src/insn/op.clj

@@ -67,7 +67,7 @@
                            ~@args]
                           (let [~'&op ~field]
                             ~@body)))))
-                (alter-meta! #'~fname assoc :arglists '~alists)
+                (alter-meta! #'~fname assoc :arglists '~alists ::op true)
                 (def-op-method ~fname)))))))
 
 ;;;
@@ -236,9 +236,7 @@
   bootstrap method."
   ([v mname desc boot] (&fn v mname desc boot []))
   ([v mname desc boot args]
-   (let [boot (if (sequential? boot)
-                (apply util/handle boot)
-                boot)]
+   (let [boot (if (util/handle? boot) boot (apply util/handle boot))]
      (.visitInvokeDynamicInsn v (util/method-name mname) (util/method-desc desc)
                               boot (object-array args)))))
 
@@ -384,20 +382,19 @@
 (def-op-method pop1)
 (def-op-method trycatch)
 
+(def op?
+  "Returns true if the given value is a valid op vector."
+  (comp keyword? first))
+
 (defn op-seq
   "Return a flattened sequence of ops."
-  [xs]
-  (let [op? (comp keyword? first)
-        go (fn go [[x & xs]]
-             (lazy-seq
-              (cond
-                (op? x)
-                (cons x (go xs))
-                (seq x)
-                (concat (go x) (go xs))
-                (seq xs)
-                (go xs))))]
-    (go xs)))
+  ([xs] (op-seq op? xs))
+  ([op? [x & xs]]
+   (lazy-seq
+    (cond
+      (op? x) (cons x (op-seq xs))
+      (seq x) (concat (op-seq x) (op-seq xs))
+      (seq xs) (op-seq xs)))))
 
 (defn compile
   "Compile a sequence of op seqs to a fn that accepts an ASM
@@ -409,3 +406,24 @@
     (fn [v]
       (doseq [op ops]
         (apply (::fn op) v (::args op))))))
+
+(def ^:private keyword-opcode*
+  (into {} (for [var (vals (ns-publics *ns*))
+                 :let [m (meta var)]
+                 :when (::op m)]
+             (let [sym (:name m)
+                   field (-> sym name .toUpperCase (.replace \- \_))]
+               [(keyword sym)
+                (.getInt (.getField Opcodes field) nil)]))))
+
+(defn keyword-opcode
+  "Return the ASM opcode number as a long for the given op keyword. If
+  the keyword is invalid an error is raised."
+  ^long [k]
+  (let [v (util/check-valid "op keyword" keyword-opcode* k)]
+    (.longValue ^Integer v)))
+
+(defn emit-seq
+  "Emit the op sequence to the given ASM MethodVisitor. See `compile`."
+  [v ops]
+  ((compile ops) v))