macroexpand-1: expand (ClassName. args) to (new ClassName args)

Matches JVM Clojure behavior. Fixes constructor sugar not being
expanded, which broke code walkers like riddley/cloverage.

Author: borkdude

CHANGELOG.md

@@ -14,6 +14,7 @@ SCI is used in [babashka](https://github.com/babashka/babashka),
 
 - Fix `read` with `nil` or `false` as eof-value throwing instead of returning the eof-value
 - Fix `letfn` with duplicate function names crashing with ClassCastException
+- `macroexpand-1` now expands `(ClassName. args)` to `(new ClassName args)`, matching JVM Clojure
 - `deftype` now macroexpands to `deftype*`, matching JVM Clojure, enabling code walkers like riddley
 - `case` now macroexpands to JVM-compatible `case*` format, enabling tools like riddley and cloverage to work with SCI
 - Fix `.method` on class objects (e.g. `(.getDeclaredField String "value")`) routing to static instead of instance method path

src/sci/impl/macroexpand.cljc

@@ -19,25 +19,30 @@
                   ;; (contains? #{'for} op) (analyze ctx expr)
                   (= 'clojure.core/defrecord op) expr
                   :else
-                  (let [f (try (resolve/resolve-symbol ctx op true)
-                               (catch #?(:clj Exception :cljs :default)
-                                   _ ::unresolved))]
-                    (if (kw-identical? ::unresolved f)
-                      expr
-                      (let [var? (var? f)
-                            macro-var? (and var?
-                                            (vars/isMacro f))
-                            f (if macro-var? @f f)]
-                        (if (or macro-var? (macro? f))
-                          (apply f original-expr (:bindings ctx) (rest expr))
-                          (if (str/starts-with? (str op) ".")
-                            (let [target (second expr)
-                                  target (if (and (symbol? target)
-                                                  (interop/resolve-class ctx target))
-                                           (list 'clojure.core/identity target)
-                                           target)]
-                              (list* '. target (symbol (subs (str op) 1)) (nnext expr)))
-                            expr))))))
+                  (let [sname (str op)]
+                    (if (and (str/ends-with? sname ".")
+                             (not (str/starts-with? sname ".")))
+                      ;; ClassName. constructor sugar -> (new ClassName args...)
+                      (list* 'new (symbol (subs sname 0 (dec (count sname)))) (rest expr))
+                      (let [f (try (resolve/resolve-symbol ctx op true)
+                                   (catch #?(:clj Exception :cljs :default)
+                                       _ ::unresolved))]
+                        (if (kw-identical? ::unresolved f)
+                          expr
+                          (let [var? (var? f)
+                                macro-var? (and var?
+                                                (vars/isMacro f))
+                                f (if macro-var? @f f)]
+                            (if (or macro-var? (macro? f))
+                              (apply f original-expr (:bindings ctx) (rest expr))
+                              (if (str/starts-with? sname ".")
+                                (let [target (second expr)
+                                      target (if (and (symbol? target)
+                                                      (interop/resolve-class ctx target))
+                                               (list 'clojure.core/identity target)
+                                               target)]
+                                  (list* '. target (symbol (subs sname 1)) (nnext expr)))
+                                expr))))))))
             expr))
         expr))))
 
@@ -46,4 +51,4 @@
   (let [ex (macroexpand-1 ctx form)]
     (if (identical? ex form)
       form
-      (macroexpand ctx ex))))
+      (macroexpand ctx ex))))

test/sci/core_test.cljc

@@ -1122,6 +1122,9 @@
                    (eval* "(macroexpand-1 '(.getDeclaredFields String))")))
             (is (= '(. "foo" length)
                    (eval* "(macroexpand-1 '(.length \"foo\"))")))))
+  #?(:clj (testing "macroexpand-1 expands ClassName. constructor sugar"
+            (is (= '(new String "ABC")
+                   (eval* "(macroexpand-1 '(String. \"ABC\"))")))))
   #?(:clj (testing "macroexpand-1 accepts env as first argument"
             (is (= '(if 1 1 (clojure.core/cond))
                    (eval* "(macroexpand-1 {'a 1} '(cond 1 1))")))