WIP: Fix new-luxc's JVM back-end.

1 files changed, 48 insertions, 67 deletions

diff --git a/new-luxc/source/luxc/lang/translation/jvm/expression.jvm.lux b/new-luxc/source/luxc/lang/translation/jvm/expression.jvm.lux
index b6fed434e..ed2023476 100644
--- a/new-luxc/source/luxc/lang/translation/jvm/expression.jvm.lux
+++ b/new-luxc/source/luxc/lang/translation/jvm/expression.jvm.lux
@@ -1,86 +1,67 @@
 (.module:
-  lux
-  (lux (control monad
-                ["ex" exception #+ exception:]
-                ["p" parser])
-       (data ["e" error]
-             text/format)
-       [macro]
-       (macro ["s" syntax])
-       ["//" lang]
-       (lang ["//." reference #+ Register]
-             ["//." synthesis #+ Synthesis]
-             ["//." extension]))
-  (luxc (lang (host ["$" jvm])))
-  (// [".T" common]
-      [".T" primitive]
-      [".T" structure]
-      [".T" eval]
-      [".T" function]
-      [".T" reference]
-      [".T" case]
-      [".T" procedure]))
-
-(do-template [<name>]
-  [(exception: #export (<name> {message Text})
-     message)]
-
-  [Invalid-Function-Syntax]
-  [Unrecognized-Synthesis]
-  )
+  [lux #*
+   [language
+    [compiler
+     [synthesis (#+ Synthesis)]
+     [extension]]]]
+  [luxc
+   [lang
+    [host
+     ["_" jvm (#+ Compiler)]]]]
+  [//
+   ["." common]
+   ["." primitive]
+   ["." structure]
+   ["." reference]
+   ["." case]
+   ## ["." function]
+   ## ["." procedure]
+   ])
 
 (def: #export (translate synthesis)
-  (-> Synthesis (Meta $.Inst))
+  Compiler
   (case synthesis
-    (^ (//synthesis.bit value))
-    (primitiveT.translate-bit value)
+    (^ (synthesis.bit value))
+    (primitive.bit value)
     
-    (^ (//synthesis.i64 value))
-    (primitiveT.translate-i64 value)
+    (^ (synthesis.i64 value))
+    (primitive.i64 value)
     
-    (^ (//synthesis.f64 value))
-    (primitiveT.translate-f64 value)
+    (^ (synthesis.f64 value))
+    (primitive.f64 value)
     
-    (^ (//synthesis.text value))
-    (primitiveT.translate-text value)
+    (^ (synthesis.text value))
+    (primitive.text value)
 
-    (^code ((~ [_ (#.Nat tag)]) (~ [_ (#.Bit last?)]) (~ valueS)))
-    (structureT.translate-variant translate tag last? valueS)
+    (^ (synthesis.variant [lefts right? value]))
+    (structure.variant translate lefts right? value)
 
-    (^code [(~+ members)])
-    (structureT.translate-tuple translate members)
+    (^ (synthesis.tuple members))
+    (structure.tuple translate members)
 
-    (^ [_ (#.Form (list [_ (#.Int var)]))])
-    (if (variableL.captured? var)
-      (referenceT.translate-captured var)
-      (referenceT.translate-local var))
+    (^ (synthesis.variable variable))
+    (reference.variable variable)
 
-    [_ (#.Symbol definition)]
-    (referenceT.translate-definition definition)
+    (^ (synthesis.constant constant))
+    (reference.constant constant)
 
-    (^code ("lux let" (~ [_ (#.Nat register)]) (~ inputS) (~ exprS)))
-    (caseT.translate-let translate register inputS exprS)
+    (^ (synthesis.branch/let [input register expr]))
+    (case.let translate input register expr)
 
-    (^code ("lux case" (~ inputS) (~ pathPS)))
-    (caseT.translate-case translate inputS pathPS)
+    (^ (synthesis.branch/if [test then else]))
+    (case.if translate test then else)
 
-    (^code ("lux function" (~ [_ (#.Nat arity)]) [(~+ environment)] (~ bodyS)))
-    (case (s.run environment (p.some s.int))
-      (#e.Success environment)
-      (functionT.translate-function translate environment arity bodyS)
+    (^ (synthesis.branch/case [input path]))
+    (case.case translate input path)
 
-      _
-      (//.throw Invalid-Function-Syntax (%code synthesis)))
+    ## (^code ("lux function" (~ [_ (#.Nat arity)]) [(~+ environment)] (~ bodyS)))
+    ## (function.translate-function translate environment arity bodyS)
 
-    (^code ("lux call" (~ functionS) (~+ argsS)))
-    (functionT.translate-call translate functionS argsS)
+    ## (^code ("lux call" (~ functionS) (~+ argsS)))
+    ## (function.translate-call translate functionS argsS)
 
-    (^code ((~ [_ (#.Text procedure)]) (~+ argsS)))
-    (procedureT.translate-procedure translate procedure argsS)
-    ## (do macro.Monad<Meta>
-    ##   [translation (extensionL.find-translation procedure)]
-    ##   (translation argsS))
+    ## (^code ((~ [_ (#.Text extension)]) (~+ args)))
+    ## (extension.apply [extension args])
 
     _
-    (//.throw Unrecognized-Synthesis (%code synthesis))
-    ))
+    (undefined)))