core vars

.gitignore

@@ -3,3 +3,7 @@
 package-lock.json
 target
 node_modules
+.shadow-cljs
+lib
+report.html
+test/scratch.js

cljs.core.js

@@ -0,0 +1 @@
+export * from './lib/cljs_core.js';

corpus/core_vars.cljs

@@ -0,0 +1,9 @@
+(ns core-vars)
+
+(def js-map (clj->js (assoc nil :foo :bar)))
+
+(js/console.log js-map)
+
+(def clj-map (assoc nil :foo (+ 1 2 3)))
+
+(js/console.log (get clj-map :foo)) ;; => 6

corpus/core_vars.mjs

@@ -0,0 +1,6 @@
+import { toJs, get, keyword, assoc } from 'cherry-cljs/cljs.core.js'
+
+const js_map = toJs(assoc(null, keyword("foo"), keyword("bar")));
+console.log(js_map);
+const clj_map = assoc(null, keyword("foo"), (1 + 2 + 3));
+console.log(get(clj_map, keyword("foo")));

corpus/destructuring.cljs

@@ -0,0 +1,16 @@
+(ns destructuring)
+
+;; TODO:
+(let [{:keys [a]} x]
+
+  )
+
+;; This currently transpiles as:
+
+;; const {keys: [a]} = {a: 1};
+
+;; What we probably want:
+
+;; const _temp_object = x // the enti
+;; const a = ...
+

corpus/destructuring.mjs

@@ -0,0 +1,6 @@
+(function () {
+ const {keys: [a]} = {a: 1};
+return (function () {
+ return null;
+})();
+})();

deps.edn

@@ -1,7 +1,6 @@
 {:deps {borkdude/edamame {:mvn/version "1.0.0"}}
-
  :aliases
- {:cljs {:extra-deps {org.clojure/clojurescript {:mvn/version "1.11.60"}}}
+ {:cljs {:extra-deps {thheller/shadow-cljs {:mvn/version "2.19.6"}}}
   :test ;; added by neil
   {:extra-paths ["test"]
    :extra-deps {io.github.cognitect-labs/test-runner

package.json

@@ -1,5 +1,9 @@
 {
-  "dependencies": {
-    "mori": "^0.3.2"
-  }
+  "type": "module",
+  "name": "cherry-cljs",
+  "sideEffects": false,
+  "version": "0.0.0-alpha.4",
+  "files": ["cljs.core.js",
+            "lib/cljs_core.js"],
+  "devDependencies": {"cherry-cljs": "."}
 }

shadow-cljs.edn

@@ -0,0 +1,24 @@
+{:deps {:aliases [:cljs]}
+ :builds
+ {:cherry
+  {:js-options {;; don't bundle any npm libs
+                :js-provider :import}
+   :compiler-options {:infer-externs :auto}
+   :target :esm
+   :runtime :node
+   :output-dir "lib"
+   :modules
+   {:cljs_core {:exports {assoc cljs.core/assoc
+                          map cljs.core/map
+                          str cljs.core/str
+                          keyword cljs.core/keyword
+                          symbol cljs.core/symbol
+                          vector cljs.core/vector
+                          toJs cljs.core/clj->js
+                          toCljs cljs.core/js->clj
+                          dissoc cljs.core/dissoc
+                          conj cljs.core/conj
+                          get cljs.core/get}}
+    #_#_:transpiler {}}
+   :build-hooks [(shadow.cljs.build-report/hook
+                  {:output-to "report.html"})]}}}

src/cherry/transpiler.clj

@@ -67,16 +67,21 @@
   ;;; This is incomplete, it disallows unicode
   (boolean (re-matches #"[_$\p{Alpha}][.\w]*" (str sym))))
 
+;; TODO: move to context argument
+(def ^:dynamic *imported-core-vars* (atom #{}))
+
 (defmethod emit clojure.lang.Keyword [expr]
   (when-not (valid-symbol? (name expr))
     (#'throwf "%s is not a valid javascript symbol" expr))
-  (str (name expr)))
+  (swap! *imported-core-vars* conj 'keyword)
+  (str (format "keyword(%s)" (pr-str (subs (str expr) 1)))))
 
 (defmethod emit clojure.lang.Symbol [expr]
   (let [expr (if (and (qualified-symbol? expr)
                       (= "js" (namespace expr)))
                (name expr)
-               expr)]
+               expr)
+        expr (symbol (munge expr))]
     (when-not (valid-symbol? (str expr))
       (#' throwf "%s is not a valid javascript symbol" expr))
     (str expr)))
@@ -89,10 +94,16 @@
 
 (def special-forms (set ['var '. '.. 'if 'funcall 'fn 'quote 'set!
                          'return 'delete 'new 'do 'aget 'while 'doseq
-                         'str 'inc! 'dec! 'dec 'inc 'defined? 'and 'or
+                         'inc! 'dec! 'dec 'inc 'defined? 'and 'or
                          '? 'try 'break
                          'await 'const 'defn 'let 'ns 'def]))
 
+(def core-vars (set '[map assoc str keyword symbol
+                      dissoc conj vector clj->js js->clj get]))
+
+(def core->js '{clj->js toJs
+                js->cljs toCljs})
+
 (def prefix-unary-operators (set ['!]))
 
 (def suffix-unary-operators (set ['++ '--]))
@@ -183,10 +194,16 @@
   ;; TODO
   )
 
-(defmethod emit-special 'funcall [type [name & args]]
+(defmethod emit-special 'funcall [_type [name & args]]
   (str (if (and (list? name) (= 'fn (first name))) ; function literal call
          (str "(" (emit name) ")")
-         (emit name))
+         (let [name
+               (if (contains? core-vars name)
+                 (let [name (get core->js name name)]
+                   (swap! *imported-core-vars* conj name)
+                   name)
+                 name)]
+           (emit name)))
        (comma-list (map emit args))))
 
 (defmethod emit-special 'str [type [str & args]]
@@ -484,7 +501,15 @@
             (recur (str transpiled next-js))))))))
 
 (defn transpile-file [{:keys [in-file out-file]}]
-  (let [out-file (or out-file
-                     (str/replace in-file #".cljs$" ".mjs"))]
-    (spit out-file (transpile-string (slurp in-file)))
-    {:out-file out-file}))
+  (let [core-vars (atom #{})]
+    (binding [*imported-core-vars* core-vars]
+      (let [out-file (or out-file
+                         (str/replace in-file #".cljs$" ".mjs"))
+            transpiled (transpile-string (slurp in-file))
+            transpiled (if-let [core-vars (seq @core-vars)]
+                         (str (format "import { %s } from 'cherry-cljs/cljs.core.js'\n\n"
+                                      (str/join ", " core-vars))
+                              transpiled)
+                         transpiled)]
+        (spit out-file transpiled)
+        {:out-file out-file}))))