aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEduardo Julian2022-04-05 18:32:42 -0400
committerEduardo Julian2022-04-05 18:32:42 -0400
commit60daee098f92a44c3b404a9f5801f2e8126ad650 (patch)
tree7b58d0f6f937b8be5dcb46eaf0411f7961907c8a
parenta2d994a3f7a39964452df7523f69e16b10b266f9 (diff)
No longer depending on the ASM library for JVM bytecode generation.
-rw-r--r--.github/workflows/test.yml16
-rw-r--r--lux-jvm/project.clj12
-rw-r--r--lux-jvm/source/luxc/lang/directive/jvm.lux1522
-rw-r--r--lux-jvm/source/luxc/lang/host/jvm.lux150
-rw-r--r--lux-jvm/source/luxc/lang/host/jvm/def.lux306
-rw-r--r--lux-jvm/source/luxc/lang/host/jvm/inst.lux472
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm.lux202
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/case.lux301
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/expression.lux78
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/extension.lux17
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/extension/common.lux359
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux1248
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/function.lux359
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/loop.lux85
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/primitive.lux114
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/program.lux94
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/reference.lux67
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/runtime.lux425
-rw-r--r--lux-jvm/source/luxc/lang/translation/jvm/structure.lux118
-rw-r--r--lux-jvm/source/program.lux357
-rw-r--r--lux-jvm/source/test/program.lux18
-rw-r--r--lux-python/commands.md10
-rw-r--r--lux-python/project.lux7
-rw-r--r--lux-python/source/program.lux4
-rw-r--r--stdlib/source/library/lux/control/concurrency/atom.lux16
-rw-r--r--stdlib/source/library/lux/tool/compiler/default/platform.lux22
-rw-r--r--stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/python.lux40
-rw-r--r--stdlib/source/library/lux/world/file.lux2
-rw-r--r--stdlib/source/test/lux/target/python.lux6
-rw-r--r--stdlib/source/unsafe/lux/data/collection/array.lux30
30 files changed, 207 insertions, 6250 deletions
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 740da5621..2576c20d3 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -17,6 +17,15 @@ jobs:
with:
node-version: '14'
- run: cd ./stdlib/ && ../lux.sh with js with bibliotheca test
+ test_stdlib_on_python_3:
+ - uses: actions/checkout@v2
+ - uses: ./.github/workflows/setup_aedifex
+ # https://github.com/actions/setup-python
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.9'
+ architecture: 'x64'
+ - run: cd ./stdlib/ && ../lux.sh with python with bibliotheca test
# test_stdlib:
# runs-on: ubuntu-latest
# steps:
@@ -24,13 +33,6 @@ jobs:
# # https://github.com/marketplace/actions/setup-lua-luajit
# - uses: xpol/setup-lua@v0.3
# - run: cd ./stdlib/ && ../lux.sh clean && ../lux.sh with lua with bibliotheca test && cd ..
-# # Test on Python
-# # https://github.com/actions/setup-python
-# - uses: actions/setup-python@v2
-# with:
-# python-version: '3.9'
-# architecture: 'x64'
-# - run: cd ./stdlib/ && ../lux.sh clean && ../lux.sh with python with bibliotheca test && cd ..
# # Test on Ruby
# # https://github.com/actions/setup-ruby
# - uses: actions/setup-ruby@v1
diff --git a/lux-jvm/project.clj b/lux-jvm/project.clj
index 0705d6f8b..fa6ce9dff 100644
--- a/lux-jvm/project.clj
+++ b/lux-jvm/project.clj
@@ -19,16 +19,10 @@
:scm {:name "git"
:url ~(str repo ".git")}
- :dependencies [[com.github.luxlang/lux-bootstrapper ~version]
- [com.github.luxlang/lux-jvm-function ~version]
+ :dependencies [[com.github.luxlang/lux-bootstrapper "0.6.6-SNAPSHOT"]
+ [com.github.luxlang/lux-jvm-function "0.6.5"]
;; [com.github.luxlang/stdlib ~version]
-
- ;; JVM Bytecode (TODO: Remove ASAP)
- [org.ow2.asm/asm "7.3.1"]
- [org.ow2.asm/asm-commons "7.3.1"]
- [org.ow2.asm/asm-analysis "7.3.1"]
- [org.ow2.asm/asm-tree "7.3.1"]
- [org.ow2.asm/asm-util "7.3.1"]]
+ ]
:manifest {"lux" ~version}
:source-paths ["source"]
diff --git a/lux-jvm/source/luxc/lang/directive/jvm.lux b/lux-jvm/source/luxc/lang/directive/jvm.lux
deleted file mode 100644
index bff4a1ab4..000000000
--- a/lux-jvm/source/luxc/lang/directive/jvm.lux
+++ /dev/null
@@ -1,1522 +0,0 @@
-(.using
- [library
- [lux {"-" Type Primitive static local}
- ["[0]" ffi {"+" Inheritance Privacy State import:}]
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" pipe]
- ["[0]" try {"+" Try}]
- ["<>" parser
- ["<[0]>" code {"+" Parser}]
- ["<[0]>" text]]]
- [data
- [identity {"+" Identity}]
- [binary {"+" Binary}]
- ["[0]" product]
- [text
- ["%" format {"+" format}]]
- [collection
- [array {"+" Array}]
- ["[0]" list ("[1]#[0]" mix functor monoid)]
- ["[0]" dictionary {"+" Dictionary}]
- ["[0]" sequence {"+" Sequence} ("[1]#[0]" functor mix)]
- ["[0]" set {"+" Set}]]]
- [macro
- ["^" pattern]]
- [math
- [number
- ["[0]" nat]]]
- [target
- ["/" jvm
- [encoding
- ["[0]" name {"+" External}]]
- ["[1][0]" type {"+" Type Typed Constraint}
- [category {"+" Void Value Return Primitive Object Class Var Parameter}]
- ["[0]" parser]
- ["[0]T" lux]
- ["[1]/[0]" signature]
- ["[1]/[0]" descriptor]]]]
- [tool
- [compiler
- ["[0]" phase]
- [language
- [lux
- ["[0]" synthesis {"+" Synthesis}]
- ["[0]" generation]
- ["[0]" directive {"+" Requirements}]
- ["[0]" analysis {"+" Analysis}
- ["[0]A" type]
- ["[0]A" scope]]
- [phase
- ["[0]" extension
- ["[0]" bundle]
- [analysis
- ["//A" jvm]]
- [directive
- ["[0]/" lux]]]]]]
- [meta
- [archive {"+" Archive}
- ["[0]" unit]]
- ["[0]" cache "_"
- ["[1]" artifact]]]]]]]
- [///
- [host
- ["[0]" jvm {"+" Inst}
- ["_" inst]
- ["[0]" def]]]
- [translation
- [jvm
- [extension
- ["//G" host]]]]])
-
-(import: org/objectweb/asm/Label
- "[1]::[0]"
- (new []))
-
-(def: (literal literal)
- (-> /.Literal Inst)
- (case literal
- {/.#Boolean value} (_.boolean value)
- {/.#Int value} (_.int value)
- {/.#Long value} (_.long value)
- {/.#Double value} (_.double value)
- {/.#Char value} (_.char value)
- {/.#String value} (_.string value)))
-
-(def: (constant instruction)
- (-> /.Constant Inst)
- (case instruction
- {/.#BIPUSH constant} (_.BIPUSH constant)
-
- {/.#SIPUSH constant} (_.SIPUSH constant)
-
- {/.#ICONST_M1} _.ICONST_M1
- {/.#ICONST_0} _.ICONST_0
- {/.#ICONST_1} _.ICONST_1
- {/.#ICONST_2} _.ICONST_2
- {/.#ICONST_3} _.ICONST_3
- {/.#ICONST_4} _.ICONST_4
- {/.#ICONST_5} _.ICONST_5
-
- {/.#LCONST_0} _.LCONST_0
- {/.#LCONST_1} _.LCONST_1
-
- {/.#FCONST_0} _.FCONST_0
- {/.#FCONST_1} _.FCONST_1
- {/.#FCONST_2} _.FCONST_2
-
- {/.#DCONST_0} _.DCONST_0
- {/.#DCONST_1} _.DCONST_1
-
- {/.#ACONST_NULL} _.NULL
-
- {/.#LDC literal}
- (..literal literal)
- ))
-
-(def: (int_arithmetic instruction)
- (-> /.Int_Arithmetic Inst)
- (case instruction
- {/.#IADD} _.IADD
- {/.#ISUB} _.ISUB
- {/.#IMUL} _.IMUL
- {/.#IDIV} _.IDIV
- {/.#IREM} _.IREM
- {/.#INEG} _.INEG))
-
-(def: (long_arithmetic instruction)
- (-> /.Long_Arithmetic Inst)
- (case instruction
- {/.#LADD} _.LADD
- {/.#LSUB} _.LSUB
- {/.#LMUL} _.LMUL
- {/.#LDIV} _.LDIV
- {/.#LREM} _.LREM
- {/.#LNEG} _.LNEG))
-
-(def: (float_arithmetic instruction)
- (-> /.Float_Arithmetic Inst)
- (case instruction
- {/.#FADD} _.FADD
- {/.#FSUB} _.FSUB
- {/.#FMUL} _.FMUL
- {/.#FDIV} _.FDIV
- {/.#FREM} _.FREM
- {/.#FNEG} _.FNEG))
-
-(def: (double_arithmetic instruction)
- (-> /.Double_Arithmetic Inst)
- (case instruction
- {/.#DADD} _.DADD
- {/.#DSUB} _.DSUB
- {/.#DMUL} _.DMUL
- {/.#DDIV} _.DDIV
- {/.#DREM} _.DREM
- {/.#DNEG} _.DNEG))
-
-(def: (arithmetic instruction)
- (-> /.Arithmetic Inst)
- (case instruction
- {/.#Int_Arithmetic int_arithmetic}
- (..int_arithmetic int_arithmetic)
-
- {/.#Long_Arithmetic long_arithmetic}
- (..long_arithmetic long_arithmetic)
-
- {/.#Float_Arithmetic float_arithmetic}
- (..float_arithmetic float_arithmetic)
-
- {/.#Double_Arithmetic double_arithmetic}
- (..double_arithmetic double_arithmetic)))
-
-(def: (int_bitwise instruction)
- (-> /.Int_Bitwise Inst)
- (case instruction
- {/.#IOR} _.IOR
- {/.#IXOR} _.IXOR
- {/.#IAND} _.IAND
- {/.#ISHL} _.ISHL
- {/.#ISHR} _.ISHR
- {/.#IUSHR} _.IUSHR))
-
-(def: (long_bitwise instruction)
- (-> /.Long_Bitwise Inst)
- (case instruction
- {/.#LOR} _.LOR
- {/.#LXOR} _.LXOR
- {/.#LAND} _.LAND
- {/.#LSHL} _.LSHL
- {/.#LSHR} _.LSHR
- {/.#LUSHR} _.LUSHR))
-
-(def: (bitwise instruction)
- (-> /.Bitwise Inst)
- (case instruction
- {/.#Int_Bitwise int_bitwise}
- (..int_bitwise int_bitwise)
-
- {/.#Long_Bitwise long_bitwise}
- (..long_bitwise long_bitwise)))
-
-(def: (conversion instruction)
- (-> /.Conversion Inst)
- (case instruction
- {/.#I2B} _.I2B
- {/.#I2S} _.I2S
- {/.#I2L} _.I2L
- {/.#I2F} _.I2F
- {/.#I2D} _.I2D
- {/.#I2C} _.I2C
-
- {/.#L2I} _.L2I
- {/.#L2F} _.L2F
- {/.#L2D} _.L2D
-
- {/.#F2I} _.F2I
- {/.#F2L} _.F2L
- {/.#F2D} _.F2D
-
- {/.#D2I} _.D2I
- {/.#D2L} _.D2L
- {/.#D2F} _.D2F))
-
-(def: (array instruction)
- (-> /.Array Inst)
- (case instruction
- {/.#ARRAYLENGTH} _.ARRAYLENGTH
-
- {/.#NEWARRAY type} (_.NEWARRAY type)
- {/.#ANEWARRAY type} (_.ANEWARRAY type)
-
- {/.#BALOAD} _.BALOAD
- {/.#BASTORE} _.BASTORE
-
- {/.#SALOAD} _.SALOAD
- {/.#SASTORE} _.SASTORE
-
- {/.#IALOAD} _.IALOAD
- {/.#IASTORE} _.IASTORE
-
- {/.#LALOAD} _.LALOAD
- {/.#LASTORE} _.LASTORE
-
- {/.#FALOAD} _.FALOAD
- {/.#FASTORE} _.FASTORE
-
- {/.#DALOAD} _.DALOAD
- {/.#DASTORE} _.DASTORE
-
- {/.#CALOAD} _.CALOAD
- {/.#CASTORE} _.CASTORE
-
- {/.#AALOAD} _.AALOAD
- {/.#AASTORE} _.AASTORE))
-
-(def: (object instruction)
- (-> /.Object Inst)
- (case instruction
- (^.template [<tag> <inst>]
- [{<tag> class field_name field_type}
- (<inst> class field_name field_type)])
- ([/.#GETSTATIC _.GETSTATIC]
- [/.#PUTSTATIC _.PUTSTATIC]
- [/.#GETFIELD _.GETFIELD]
- [/.#PUTFIELD _.PUTFIELD])
-
- {/.#NEW type} (_.NEW type)
-
- {/.#INSTANCEOF type} (_.INSTANCEOF type)
- {/.#CHECKCAST type} (_.CHECKCAST type)
-
- (^.template [<tag> <inst>]
- [{<tag> class method_name method_type}
- (<inst> class method_name method_type)])
- ([/.#INVOKEINTERFACE _.INVOKEINTERFACE]
- [/.#INVOKESPECIAL _.INVOKESPECIAL]
- [/.#INVOKESTATIC _.INVOKESTATIC]
- [/.#INVOKEVIRTUAL _.INVOKEVIRTUAL])
- ))
-
-(def: (local_int instruction)
- (-> /.Local_Int Inst)
- (case instruction
- {/.#ILOAD register} (_.ILOAD register)
- {/.#ISTORE register} (_.ISTORE register)))
-
-(def: (local_long instruction)
- (-> /.Local_Long Inst)
- (case instruction
- {/.#LLOAD register} (_.LLOAD register)
- {/.#LSTORE register} (_.LSTORE register)))
-
-(def: (local_float instruction)
- (-> /.Local_Float Inst)
- (case instruction
- {/.#FLOAD register} (_.FLOAD register)
- {/.#FSTORE register} (_.FSTORE register)))
-
-(def: (local_double instruction)
- (-> /.Local_Double Inst)
- (case instruction
- {/.#DLOAD register} (_.DLOAD register)
- {/.#DSTORE register} (_.DSTORE register)))
-
-(def: (local_object instruction)
- (-> /.Local_Object Inst)
- (case instruction
- {/.#ALOAD register} (_.ALOAD register)
- {/.#ASTORE register} (_.ASTORE register)))
-
-(def: (local instruction)
- (-> /.Local Inst)
- (case instruction
- {/.#Local_Int instruction} (..local_int instruction)
- {/.#IINC register} (_.IINC register)
- {/.#Local_Long instruction} (..local_long instruction)
- {/.#Local_Float instruction} (..local_float instruction)
- {/.#Local_Double instruction} (..local_double instruction)
- {/.#Local_Object instruction} (..local_object instruction)))
-
-(def: (stack instruction)
- (-> /.Stack Inst)
- (case instruction
- {/.#DUP} _.DUP
- {/.#DUP_X1} _.DUP_X1
- {/.#DUP_X2} _.DUP_X2
- {/.#DUP2} _.DUP2
- {/.#DUP2_X1} _.DUP2_X1
- {/.#DUP2_X2} _.DUP2_X2
- {/.#SWAP} _.SWAP
- {/.#POP} _.POP
- {/.#POP2} _.POP2))
-
-(def: (comparison instruction)
- (-> /.Comparison Inst)
- (case instruction
- {/.#LCMP} _.LCMP
-
- {/.#FCMPG} _.FCMPG
- {/.#FCMPL} _.FCMPL
-
- {/.#DCMPG} _.DCMPG
- {/.#DCMPL} _.DCMPL))
-
-(def: (branching instruction)
- (-> (/.Branching org/objectweb/asm/Label) Inst)
- (case instruction
- {/.#IF_ICMPEQ label} (_.IF_ICMPEQ label)
- {/.#IF_ICMPGE label} (_.IF_ICMPGE label)
- {/.#IF_ICMPGT label} (_.IF_ICMPGT label)
- {/.#IF_ICMPLE label} (_.IF_ICMPLE label)
- {/.#IF_ICMPLT label} (_.IF_ICMPLT label)
- {/.#IF_ICMPNE label} (_.IF_ICMPNE label)
- {/.#IFEQ label} (_.IFEQ label)
- {/.#IFGE label} (_.IFGE label)
- {/.#IFGT label} (_.IFGT label)
- {/.#IFLE label} (_.IFLE label)
- {/.#IFLT label} (_.IFLT label)
- {/.#IFNE label} (_.IFNE label)
-
- {/.#TABLESWITCH min max default labels}
- (_.TABLESWITCH min max default labels)
-
- {/.#LOOKUPSWITCH default keys+labels}
- (_.LOOKUPSWITCH default keys+labels)
-
- {/.#IF_ACMPEQ label} (_.IF_ACMPEQ label)
- {/.#IF_ACMPNE label} (_.IF_ACMPNE label)
- {/.#IFNONNULL label} (_.IFNONNULL label)
- {/.#IFNULL label} (_.IFNULL label)))
-
-(def: (exception instruction)
- (-> (/.Exception org/objectweb/asm/Label) Inst)
- (case instruction
- {/.#Try start end handler exception} (_.try start end handler exception)
- {/.#ATHROW} _.ATHROW))
-
-(def: (concurrency instruction)
- (-> /.Concurrency Inst)
- (case instruction
- {/.#MONITORENTER} _.MONITORENTER
- {/.#MONITOREXIT} _.MONITOREXIT))
-
-(def: (return instruction)
- (-> /.Return Inst)
- (case instruction
- {/.#RETURN} _.RETURN
- {/.#IRETURN} _.IRETURN
- {/.#LRETURN} _.LRETURN
- {/.#FRETURN} _.FRETURN
- {/.#DRETURN} _.DRETURN
- {/.#ARETURN} _.ARETURN))
-
-(def: (control instruction)
- (-> (/.Control org/objectweb/asm/Label) Inst)
- (case instruction
- {/.#GOTO label} (_.GOTO label)
- {/.#Branching instruction} (..branching instruction)
- {/.#Exception instruction} (..exception instruction)
- {/.#Concurrency instruction} (..concurrency instruction)
- {/.#Return instruction} (..return instruction)))
-
-(def: (instruction instruction)
- (-> (/.Instruction Inst org/objectweb/asm/Label) Inst)
- (case instruction
- {/.#NOP} _.NOP
- {/.#Constant instruction} (..constant instruction)
- {/.#Arithmetic instruction} (..arithmetic instruction)
- {/.#Bitwise instruction} (..bitwise instruction)
- {/.#Conversion instruction} (..conversion instruction)
- {/.#Array instruction} (..array instruction)
- {/.#Object instruction} (..object instruction)
- {/.#Local instruction} (..local instruction)
- {/.#Stack instruction} (..stack instruction)
- {/.#Comparison instruction} (..comparison instruction)
- {/.#Control instruction} (..control instruction)
- {/.#Embedded embedded} embedded))
-
-(type: Mapping
- (Dictionary /.Label org/objectweb/asm/Label))
-
-(type: (Re_labeler context)
- (-> [Mapping (context /.Label)]
- [Mapping (context org/objectweb/asm/Label)]))
-
-(def: (relabel [mapping label])
- (Re_labeler Identity)
- (case (dictionary.value label mapping)
- {.#Some label}
- [mapping label]
-
- {.#None}
- (let [label' (org/objectweb/asm/Label::new)]
- [(dictionary.has label label' mapping) label'])))
-
-(def: (relabel_branching [mapping instruction])
- (Re_labeler /.Branching)
- (case instruction
- (^.template [<tag>]
- [{<tag> label}
- (let [[mapping label] (..relabel [mapping label])]
- [mapping {<tag> label}])])
- ([/.#IF_ICMPEQ] [/.#IF_ICMPGE] [/.#IF_ICMPGT] [/.#IF_ICMPLE] [/.#IF_ICMPLT] [/.#IF_ICMPNE]
- [/.#IFEQ] [/.#IFNE] [/.#IFGE] [/.#IFGT] [/.#IFLE] [/.#IFLT]
-
- [/.#IF_ACMPEQ] [/.#IF_ACMPNE] [/.#IFNONNULL] [/.#IFNULL])
-
- {/.#TABLESWITCH min max default labels}
- (let [[mapping default] (..relabel [mapping default])
- [mapping labels] (list#mix (function (_ input [mapping output])
- (let [[mapping input] (..relabel [mapping input])]
- [mapping (list& input output)]))
- [mapping (list)] labels)]
- [mapping {/.#TABLESWITCH min max default (list.reversed labels)}])
-
- {/.#LOOKUPSWITCH default keys+labels}
- (let [[mapping default] (..relabel [mapping default])
- [mapping keys+labels] (list#mix (function (_ [expected input] [mapping output])
- (let [[mapping input] (..relabel [mapping input])]
- [mapping (list& [expected input] output)]))
- [mapping (list)] keys+labels)]
- [mapping {/.#LOOKUPSWITCH default (list.reversed keys+labels)}])
- ))
-
-(def: (relabel_exception [mapping instruction])
- (Re_labeler /.Exception)
- (case instruction
- {/.#Try start end handler exception}
- (let [[mapping start] (..relabel [mapping start])
- [mapping end] (..relabel [mapping end])
- [mapping handler] (..relabel [mapping handler])]
- [mapping {/.#Try start end handler exception}])
-
- {/.#ATHROW}
- [mapping {/.#ATHROW}]
- ))
-
-(def: (relabel_control [mapping instruction])
- (Re_labeler /.Control)
- (case instruction
- (^.template [<tag> <relabel>]
- [{<tag> instruction}
- (let [[mapping instruction] (<relabel> [mapping instruction])]
- [mapping {<tag> instruction}])])
- ([/.#GOTO ..relabel]
- [/.#Branching ..relabel_branching]
- [/.#Exception ..relabel_exception])
-
- (^.template [<tag>]
- [{<tag> instruction}
- [mapping {<tag> instruction}]])
- ([/.#Concurrency] [/.#Return])
- ))
-
-(def: (relabel_instruction [mapping instruction])
- (Re_labeler (/.Instruction Inst))
- (case instruction
- {/.#Embedded embedded}
- [mapping {/.#Embedded embedded}]
-
- {/.#NOP}
- [mapping {/.#NOP}]
-
- (^.template [<tag>]
- [{<tag> instruction}
- [mapping {<tag> instruction}]])
- ([/.#Constant]
- [/.#Arithmetic]
- [/.#Bitwise]
- [/.#Conversion]
- [/.#Array]
- [/.#Object]
- [/.#Local]
- [/.#Stack]
- [/.#Comparison])
-
- {/.#Control instruction}
- (let [[mapping instruction] (..relabel_control [mapping instruction])]
- [mapping {/.#Control instruction}])))
-
-(def: (relabel_bytecode [mapping bytecode])
- (Re_labeler (/.Bytecode Inst))
- (sequence#mix (function (_ input [mapping output])
- (let [[mapping input'] (..relabel_instruction [mapping input])]
- [mapping (sequence.suffix input' output)]))
- [mapping (sequence.sequence)]
- bytecode))
-
-(def: fresh
- Mapping
- (dictionary.empty nat.hash))
-
-(def: bytecode
- (-> (/.Bytecode Inst /.Label) jvm.Inst)
- (|>> [..fresh]
- ..relabel_bytecode
- product.right
- (sequence#each ..instruction)
- sequence.list
- _.fuse))
-
-(with_expansions [<anchor> (these jvm.Anchor)
- <expression> (these Inst)
- <directive> (these jvm.Definition)
- <type_vars> (these <anchor> <expression> <directive>)]
- (type: Handler'
- ... (generation.Handler jvm.Anchor (/.Bytecode Inst /.Label) jvm.Definition)
- (-> extension.Name
- (phase.Phase [(extension.Bundle <type_vars>)
- (generation.State <type_vars>)]
- Synthesis
- <expression>)
- (phase.Phase [(extension.Bundle <type_vars>)
- (generation.State <type_vars>)]
- (List Synthesis)
- (/.Bytecode Inst /.Label)))))
-
-(def: (true_handler extender pseudo)
- (-> jvm.Extender Any jvm.Handler)
- (function (_ extension_name phase archive inputs)
- (# phase.monad each
- (|>> (as (/.Bytecode Inst /.Label)) ..bytecode)
- ((extender pseudo) extension_name phase archive inputs))))
-
-(type: Phase (directive.Phase jvm.Anchor jvm.Inst jvm.Definition))
-(type: Operation (directive.Operation jvm.Anchor jvm.Inst jvm.Definition))
-(type: Handler (directive.Handler jvm.Anchor jvm.Inst jvm.Definition))
-
-(def: (def::generation extender)
- (-> jvm.Extender ..Handler)
- (function (handler extension_name phase archive inputsC+)
- (case inputsC+
- (pattern (list nameC valueC))
- (do phase.monad
- [[_ _ name] (lux/.evaluate! archive Text nameC)
- [_ handlerV] (lux/.generator archive (as Text name) ..Handler' valueC)
- _ (|> handlerV
- (..true_handler extender)
- (extension.install extender (as Text name))
- directive.lifted_generation)
- _ (directive.lifted_generation
- (generation.log! (format "Generation " (%.text (as Text name)))))]
- (in directive.no_requirements))
-
- _
- (phase.except extension.invalid_syntax [extension_name %.code inputsC+]))))
-
-(def: .public (custom [parser handler])
- (All (_ i)
- (-> [(Parser i)
- (-> Text ..Phase Archive i (..Operation Requirements))]
- ..Handler))
- (function (_ extension_name phase archive input)
- (case (<code>.result parser input)
- {try.#Success input'}
- (handler extension_name phase archive input')
-
- {try.#Failure error}
- (phase.except extension.invalid_syntax [extension_name %.code input]))))
-
-(type: Declaration
- [External (List (Type Var))])
-
-(template [<name> <type> <parser>]
- [(def: <name>
- (Parser <type>)
- (do [! <>.monad]
- [raw <code>.text]
- (<>.lifted (<text>.result <parser> raw))))]
-
- [class_declaration Declaration parser.declaration']
- [class (Type Class) parser.class]
- [type_variable (Type Var) parser.var]
- [value (Type Value) parser.value]
- [return_type (Type Return) parser.return]
- )
-
-(type: Annotation
- Code)
-
-(def: annotation
- (Parser Annotation)
- <code>.any)
-
-(type: Method_Declaration
- (Record
- [#name Text
- #annotations (List Annotation)
- #type_variables (List (Type Var))
- #exceptions (List (Type Class))
- #arguments (List (Type Value))
- #return (Type Value)]))
-
-(def: method_declaration
- (Parser Method_Declaration)
- (<code>.form
- ($_ <>.and
- <code>.text
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- (<code>.tuple (<>.some ..class))
- (<code>.tuple (<>.some ..value))
- ..value
- )))
-
-(def: java/lang/Object
- (/type.class "java.lang.Object" (list)))
-
-(def: inheritance
- (Parser Inheritance)
- ($_ <>.or
- (<code>.this_text "final")
- (<code>.this_text "abstract")
- (<code>.this_text "default")
- ))
-
-(def: privacy
- (Parser Privacy)
- ($_ <>.or
- (<code>.this_text "public")
- (<code>.this_text "private")
- (<code>.this_text "protected")
- (<code>.this_text "default")
- ))
-
-(def: state
- (Parser State)
- ($_ <>.or
- (<code>.this_text "volatile")
- (<code>.this_text "final")
- (<code>.this_text "default")
- ))
-
-(type: Field
- [Text Privacy State (List Annotation) (Type Value)])
-
-(def: field
- (Parser Field)
- (<code>.form
- (do <>.monad
- [_ (<code>.this_text "variable")
- name <code>.text
- privacy ..privacy
- state ..state
- _ (<code>.tuple (<>.some ..annotation))
- type ..value]
- (in [name privacy state (list) type]))))
-
-(type: Argument
- [Text (Type Value)])
-
-(def: argument
- (Parser Argument)
- (<code>.tuple
- (<>.and <code>.text
- ..value)))
-
-(type: (Constructor a)
- [Privacy Bit (List Annotation) (List (Type Var)) (List (Type Class))
- Text (List Argument) (List (Typed a))
- a])
-
-(type: (Override a)
- [Declaration Text Bit (List Annotation) (List (Type Var))
- Text (List Argument) (Type Return) (List (Type Class))
- a])
-
-(type: (Virtual a)
- [Text Privacy Bit Bit (List Annotation) (List (Type Var))
- Text (List Argument) (Type Return) (List (Type Class))
- a])
-
-(type: (Static a)
- [Text Privacy Bit (List Annotation) (List (Type Var))
- (List Argument) (Type Return) (List (Type Class))
- a])
-
-(type: Abstract
- [Text Privacy (List Annotation) (List (Type Var))
- (List Argument) (Type Return) (List (Type Class))])
-
-(type: (Method a)
- (Variant
- {#Constructor (Constructor a)}
- {#Override (Override a)}
- {#Virtual (Virtual a)}
- {#Static (Static a)}
- {#Abstract Abstract}))
-
-(def: (method_dependencies archive method)
- (-> Archive (Method Synthesis)
- (generation.Operation jvm.Anchor jvm.Inst jvm.Definition
- (Set unit.ID)))
- (case method
- {#Constructor [privacy strict_floating_point? annotations variables exceptions
- self arguments constructor_arguments
- body]}
- (do [! phase.monad]
- [all_super_ctor_dependencies (monad.each ! (|>> product.right (cache.dependencies archive))
- constructor_arguments)
- body_dependencies (cache.dependencies archive body)]
- (in (cache.all (list& body_dependencies all_super_ctor_dependencies))))
-
-
- (^.or {#Override [[parent_name parent_variables] name strict_floating_point? annotations variables
- self arguments return exceptions
- body]}
- {#Virtual [name privacy final? strict_floating_point? annotations variables
- self arguments return exceptions
- body]}
- {#Static [name privacy strict_floating_point? annotations variables
- arguments return exceptions
- body]})
- (cache.dependencies archive body)
-
- {#Abstract _}
- (# phase.monad in unit.none)))
-
-(def: constructor
- (Parser (Constructor Code))
- (let [constructor_argument (is (Parser [(Type Value) Code])
- (<code>.tuple
- (<>.and ..value
- <code>.any)))]
- (<| <code>.form
- (<>.after (<code>.this_text "init"))
- ($_ <>.and
- ..privacy
- <code>.bit
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- (<code>.tuple (<>.some ..class))
- <code>.text
- (<code>.tuple (<>.some ..argument))
- (<code>.tuple (<>.some constructor_argument))
- <code>.any
- ))))
-
-(def: override
- (Parser (Override Code))
- (<| <code>.form
- (<>.after (<code>.this_text "override"))
- ($_ <>.and
- ..class_declaration
- <code>.text
- <code>.bit
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- <code>.text
- (<code>.tuple (<>.some ..argument))
- ..return_type
- (<code>.tuple (<>.some ..class))
- <code>.any
- )))
-
-(def: virtual
- (Parser (Virtual Code))
- (<| <code>.form
- (<>.after (<code>.this_text "virtual"))
- ($_ <>.and
- <code>.text
- ..privacy
- <code>.bit
- <code>.bit
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- <code>.text
- (<code>.tuple (<>.some ..argument))
- ..return_type
- (<code>.tuple (<>.some ..class))
- <code>.any
- )))
-
-(def: static
- (Parser (Static Code))
- (<| <code>.form
- (<>.after (<code>.this_text "static"))
- ($_ <>.and
- <code>.text
- ..privacy
- <code>.bit
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- (<code>.tuple (<>.some ..argument))
- ..return_type
- (<code>.tuple (<>.some ..class))
- <code>.any
- )))
-
-(def: abstract
- (Parser Abstract)
- (<| <code>.form
- (<>.after (<code>.this_text "abstract"))
- ($_ <>.and
- <code>.text
- ..privacy
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..type_variable))
- (<code>.tuple (<>.some ..argument))
- ..return_type
- (<code>.tuple (<>.some ..class))
- )))
-
-(def: method
- (Parser (Method Code))
- ($_ <>.or
- ..constructor
- ..override
- ..virtual
- ..static
- ..abstract
- ))
-
-(def: (constraint tv)
- (-> (Type Var) Constraint)
- [/type.#name (parser.name tv)
- /type.#super_class java/lang/Object
- /type.#super_interfaces (list)])
-
-(def: visibility
- (-> ffi.Privacy jvm.Visibility)
- (|>> (pipe.case {ffi.#PublicP} {jvm.#Public}
- {ffi.#PrivateP} {jvm.#Private}
- {ffi.#ProtectedP} {jvm.#Protected}
- {ffi.#DefaultP} {jvm.#Default})))
-
-(def: field_config
- (-> ffi.State jvm.Field_Config)
- (|>> (pipe.case {ffi.#VolatileS} jvm.volatileF
- {ffi.#FinalS} jvm.finalF
- {ffi.#DefaultS} jvm.noneF)))
-
-(def: (field_header [name privacy state annotations type])
- (-> Field jvm.Def)
- (def.field (..visibility privacy) (..field_config state) name type))
-
-(def: (header_value valueT)
- (-> (Type Value) Inst)
- (case (/type.primitive? valueT)
- {.#Left classT}
- _.NULL
-
- {.#Right primitiveT}
- (cond (or (# /type.equivalence = /type.boolean primitiveT)
- (# /type.equivalence = /type.byte primitiveT)
- (# /type.equivalence = /type.short primitiveT)
- (# /type.equivalence = /type.int primitiveT)
- (# /type.equivalence = /type.char primitiveT))
- _.ICONST_0
-
- (# /type.equivalence = /type.long primitiveT)
- _.LCONST_0
-
- (# /type.equivalence = /type.float primitiveT)
- _.FCONST_0
-
- ... (# /type.equivalence = /type.double primitiveT)
- _.DCONST_0)))
-
-(def: (header_return returnT)
- (-> (Type Return) Inst)
- (case (/type.void? returnT)
- {.#Right returnT}
- _.RETURN
-
- {.#Left valueT}
- (case (/type.primitive? valueT)
- {.#Left classT}
- (|>> (header_value classT)
- _.ARETURN)
-
- {.#Right primitiveT}
- (cond (or (# /type.equivalence = /type.boolean primitiveT)
- (# /type.equivalence = /type.byte primitiveT)
- (# /type.equivalence = /type.short primitiveT)
- (# /type.equivalence = /type.int primitiveT)
- (# /type.equivalence = /type.char primitiveT))
- (|>> (header_value primitiveT)
- _.IRETURN)
-
- (# /type.equivalence = /type.long primitiveT)
- (|>> (header_value primitiveT)
- _.LRETURN)
-
- (# /type.equivalence = /type.float primitiveT)
- (|>> (header_value primitiveT)
- _.FRETURN)
-
- ... (# /type.equivalence = /type.double primitiveT)
- (|>> (header_value primitiveT)
- _.DRETURN)))))
-
-(def: constructor_name
- "<init>")
-
-(def: (abstract_method_generation method)
- (-> Abstract jvm.Def)
- (let [[name privacy annotations variables
- arguments return exceptions] method]
- (def.abstract_method (..visibility privacy)
- jvm.noneM
- name
- (/type.method [variables (list#each product.right arguments) return exceptions]))))
-
-(def: (method_header super_class method)
- (-> (Type Class) (Method Code) jvm.Def)
- (case method
- {#Constructor [privacy strict_floating_point? annotations variables exceptions
- self arguments constructor_arguments
- body]}
- (let [[super_name super_vars] (parser.read_class super_class)
- init_constructor_arguments (|> constructor_arguments
- (list#each (|>> product.left ..header_value))
- _.fuse)
- super_constructorT (/type.method [(list)
- (list#each product.left constructor_arguments)
- /type.void
- (list)])]
- (def.method (..visibility privacy)
- (if strict_floating_point?
- jvm.strictM
- jvm.noneM)
- ..constructor_name
- (/type.method [variables (list#each product.right arguments) /type.void exceptions])
- (|>> (_.ALOAD 0)
- init_constructor_arguments
- (_.INVOKESPECIAL super_class ..constructor_name super_constructorT)
- _.RETURN)))
-
- {#Override [[parent_name parent_variables] name strict_floating_point? annotations variables
- self arguments return exceptions
- body]}
- (def.method {jvm.#Public}
- (if strict_floating_point?
- jvm.strictM
- jvm.noneM)
- name
- (/type.method [variables (list#each product.right arguments) return exceptions])
- (..header_return return))
-
- {#Virtual [name privacy final? strict_floating_point? annotations variables
- self arguments return exceptions
- body]}
- (def.method (..visibility privacy)
- (|> jvm.noneM
- (jvm.++M (if strict_floating_point?
- jvm.strictM
- jvm.noneM))
- (jvm.++M (if final?
- jvm.finalM
- jvm.noneM)))
- name
- (/type.method [variables (list#each product.right arguments) return exceptions])
- (..header_return return))
-
- {#Static [name privacy strict_floating_point? annotations variables
- arguments return exceptions
- body]}
- (def.method (..visibility privacy)
- (|> jvm.staticM
- (jvm.++M (if strict_floating_point?
- jvm.strictM
- jvm.noneM)))
- name
- (/type.method [variables (list#each product.right arguments) return exceptions])
- (..header_return return))
-
- {#Abstract method}
- (..abstract_method_generation method)
- ))
-
-(def: (header [class_name type_variables]
- super_class
- super_interfaces
- inheritance
- fields
- methods)
- (-> Declaration
- (Type Class)
- (List (Type Class))
- Inheritance
- (List Field)
- (List (Method Code))
- [External Binary])
- (let [constraints (list#each ..constraint type_variables)
- field_definitions (list#each ..field_header fields)
- method_definitions (list#each (..method_header super_class) methods)
- definitions (def.fuse (list#composite field_definitions
- method_definitions))]
- [class_name
- (case inheritance
- {ffi.#DefaultI}
- (def.class {jvm.#V1_6} {jvm.#Public} jvm.noneC class_name constraints super_class super_interfaces
- definitions)
-
- {ffi.#FinalI}
- (def.class {jvm.#V1_6} {jvm.#Public} jvm.finalC class_name constraints super_class super_interfaces
- definitions)
-
- {ffi.#AbstractI}
- (def.abstract {jvm.#V1_6} {jvm.#Public} jvm.noneC class_name constraints super_class super_interfaces
- definitions))]))
-
-(def: (constructor_method_analysis archive [class_name class_tvars] method)
- (-> Archive Declaration (Constructor Code) (Operation (Constructor Analysis)))
- (do [! phase.monad]
- [.let [[privacy strict_floating_point? annotations method_tvars exceptions
- self arguments constructor_argumentsC
- bodyC] method]
- analyse directive.analysis]
- (directive.lifted_analysis
- (do !
- [mapping (//A.with_fresh_type_vars class_tvars luxT.fresh)
- mapping (//A.with_fresh_type_vars method_tvars mapping)
- constructor_argumentsA (monad.each ! (function (_ [typeJ termC])
- (do !
- [typeL (//A.reflection_type mapping typeJ)
- termA (<| (typeA.expecting typeL)
- (analyse archive termC))]
- (in [typeJ termA])))
- constructor_argumentsC)
- selfT (//A.reflection_type mapping (/type.class class_name class_tvars))
- arguments' (monad.each !
- (function (_ [name type])
- (# ! each (|>> [name])
- (//A.boxed_reflection_type mapping type)))
- arguments)
- returnT (//A.boxed_reflection_return mapping /type.void)
- [_scope bodyA] (|> arguments'
- {.#Item [self selfT]}
- list.reversed
- (list#mix scopeA.with_local (analyse archive bodyC))
- (typeA.expecting returnT)
- scopeA.with)]
- (in [privacy strict_floating_point? annotations method_tvars exceptions
- self arguments constructor_argumentsA
- bodyA])))))
-
-(def: (override_method_analysis archive [class_name class_tvars] supers method)
- (-> Archive Declaration (List (Type Class)) (Override Code) (Operation (Override Analysis)))
- (do [! phase.monad]
- [.let [[[super_name super_tvars] method_name strict_floating_point? annotations
- method_tvars self arguments returnJ exceptionsJ
- bodyC] method]
- analyse directive.analysis]
- (directive.lifted_analysis
- (do !
- [mapping (//A.with_fresh_type_vars class_tvars luxT.fresh)
- .let [parent_type (/type.class super_name super_tvars)]
- mapping (//A.with_override_mapping supers parent_type mapping)
- mapping (//A.with_fresh_type_vars method_tvars mapping)
- selfT (//A.reflection_type mapping (/type.class class_name class_tvars))
- arguments' (monad.each !
- (function (_ [name type])
- (# ! each (|>> [name])
- (//A.boxed_reflection_type mapping type)))
- arguments)
- returnT (//A.boxed_reflection_return mapping returnJ)
- [_scope bodyA] (|> arguments'
- {.#Item [self selfT]}
- list.reversed
- (list#mix scopeA.with_local (analyse archive bodyC))
- (typeA.expecting returnT)
- scopeA.with)]
- (in [[super_name super_tvars] method_name strict_floating_point? annotations
- method_tvars self arguments returnJ exceptionsJ
- bodyA])))))
-
-(def: (virtual_method_analysis archive [class_name class_tvars] method)
- (-> Archive Declaration (Virtual Code) (Operation (Virtual Analysis)))
- (do [! phase.monad]
- [.let [[name privacy final? strict_floating_point? annotations method_tvars
- self arguments returnJ exceptionsJ
- bodyC] method]
- analyse directive.analysis]
- (directive.lifted_analysis
- (do !
- [mapping (//A.with_fresh_type_vars class_tvars luxT.fresh)
- mapping (//A.with_fresh_type_vars method_tvars mapping)
- selfT (//A.reflection_type mapping (/type.class class_name class_tvars))
- arguments' (monad.each !
- (function (_ [name type])
- (# ! each (|>> [name])
- (//A.boxed_reflection_type mapping type)))
- arguments)
- returnT (//A.boxed_reflection_return mapping returnJ)
- [_scope bodyA] (|> arguments'
- {.#Item [self selfT]}
- list.reversed
- (list#mix scopeA.with_local (analyse archive bodyC))
- (typeA.expecting returnT)
- scopeA.with)]
- (in [name privacy final? strict_floating_point? annotations method_tvars
- self arguments returnJ exceptionsJ
- bodyA])))))
-
-(def: (static_method_analysis archive method)
- (-> Archive (Static Code) (Operation (Static Analysis)))
- (do [! phase.monad]
- [.let [[name privacy strict_floating_point? annotations method_tvars
- arguments returnJ exceptionsJ
- bodyC] method]
- analyse directive.analysis]
- (directive.lifted_analysis
- (do !
- [mapping (//A.with_fresh_type_vars method_tvars luxT.fresh)
- arguments' (monad.each !
- (function (_ [name type])
- (# ! each (|>> [name])
- (//A.boxed_reflection_type mapping type)))
- arguments)
- returnT (//A.boxed_reflection_return mapping returnJ)
- [_scope bodyA] (|> arguments'
- list.reversed
- (list#mix scopeA.with_local (analyse archive bodyC))
- (typeA.expecting returnT)
- scopeA.with)]
- (in [name privacy strict_floating_point? annotations method_tvars
- arguments returnJ exceptionsJ
- bodyA])))))
-
-(def: (method_analysis archive declaration supers method)
- (-> Archive Declaration (List (Type Class)) (Method Code) (Operation (Method Analysis)))
- (case method
- {#Constructor method}
- (# phase.monad each (|>> {#Constructor})
- (constructor_method_analysis archive declaration method))
-
- {#Override method}
- (# phase.monad each (|>> {#Override})
- (override_method_analysis archive declaration supers method))
-
- {#Virtual method}
- (# phase.monad each (|>> {#Virtual})
- (virtual_method_analysis archive declaration method))
-
- {#Static method}
- (# phase.monad each (|>> {#Static})
- (static_method_analysis archive method))
-
- {#Abstract method}
- (# phase.monad in {#Abstract method})
- ))
-
-(template: (method_body <bodyS>)
- [(<| synthesis.function/abstraction [_ _]
- synthesis.loop/scope [_ _]
- synthesis.tuple
- (list _)
- <bodyS>)])
-
-(def: (constructor_method_synthesis archive method)
- (-> Archive (Constructor Analysis) (Operation (Constructor Synthesis)))
- (do [! phase.monad]
- [.let [[privacy strict_floating_point? annotations method_tvars exceptions
- self arguments constructor_argumentsA
- bodyA] method]
- synthesise directive.synthesis]
- (directive.lifted_synthesis
- (do !
- [constructor_argumentsS (monad.each ! (function (_ [typeJ termA])
- (# ! each (|>> [typeJ])
- (synthesise archive termA)))
- constructor_argumentsA)
- bodyS (synthesise archive {analysis.#Function (list) (//A.hidden_method_body (list.size arguments) bodyA)})]
- (in [privacy strict_floating_point? annotations method_tvars exceptions
- self arguments constructor_argumentsS
- (case bodyS
- (pattern (method_body bodyS))
- bodyS
-
- _
- bodyS)])))))
-
-(def: (override_method_synthesis archive method)
- (-> Archive (Override Analysis) (Operation (Override Synthesis)))
- (do [! phase.monad]
- [.let [[[super_name super_tvars] method_name strict_floating_point? annotations
- method_tvars self arguments returnJ exceptionsJ
- bodyA] method]
- synthesise directive.synthesis]
- (directive.lifted_synthesis
- (do !
- [bodyS (synthesise archive {analysis.#Function (list) (//A.hidden_method_body (list.size arguments) bodyA)})]
- (in [[super_name super_tvars] method_name strict_floating_point? annotations
- method_tvars self arguments returnJ exceptionsJ
- (case bodyS
- (pattern (method_body bodyS))
- bodyS
-
- _
- bodyS)])))))
-
-(def: (virtual_method_synthesis archive method)
- (-> Archive (Virtual Analysis) (Operation (Virtual Synthesis)))
- (do [! phase.monad]
- [.let [[name privacy final? strict_floating_point? annotations method_tvars
- self arguments returnJ exceptionsJ
- bodyA] method]
- synthesise directive.synthesis]
- (directive.lifted_synthesis
- (do !
- [bodyS (synthesise archive {analysis.#Function (list) (//A.hidden_method_body (list.size arguments) bodyA)})]
- (in [name privacy final? strict_floating_point? annotations method_tvars
- self arguments returnJ exceptionsJ
- (case bodyS
- (pattern (method_body bodyS))
- bodyS
-
- _
- bodyS)])))))
-
-(def: (static_method_synthesis archive method)
- (-> Archive (Static Analysis) (Operation (Static Synthesis)))
- (do [! phase.monad]
- [.let [[name privacy strict_floating_point? annotations method_tvars
- arguments returnJ exceptionsJ
- bodyA] method]
- synthesise directive.synthesis]
- (directive.lifted_synthesis
- (do !
- [bodyS (synthesise archive {analysis.#Function (list) (//A.hidden_method_body (list.size arguments) bodyA)})]
- (in [name privacy strict_floating_point? annotations method_tvars
- arguments returnJ exceptionsJ
- (case bodyS
- (pattern (method_body bodyS))
- bodyS
-
- _
- bodyS)])))))
-
-(def: (method_synthesis archive method)
- (-> Archive (Method Analysis) (Operation (Method Synthesis)))
- (case method
- {#Constructor method}
- (# phase.monad each (|>> {#Constructor})
- (constructor_method_synthesis archive method))
-
- {#Override method}
- (# phase.monad each (|>> {#Override})
- (override_method_synthesis archive method))
-
- {#Virtual method}
- (# phase.monad each (|>> {#Virtual})
- (virtual_method_synthesis archive method))
-
- {#Static method}
- (# phase.monad each (|>> {#Static})
- (static_method_synthesis archive method))
-
- {#Abstract method}
- (# phase.monad in {#Abstract method})
- ))
-
-(def: (constructor_method_generation archive super_class method)
- (-> Archive (Type Class) (Constructor Synthesis) (Operation jvm.Def))
- (do [! phase.monad]
- [.let [[privacy strict_floating_point? annotations method_tvars exceptions
- self arguments constructor_argumentsS
- bodyS] method]
- generate directive.generation]
- (directive.lifted_generation
- (do !
- [constructor_argumentsG (monad.each ! (|>> product.right (generate archive))
- constructor_argumentsS)
- bodyG (generate archive (//G.hidden_method_body (list.size arguments) bodyS))
- .let [[super_name super_vars] (parser.read_class super_class)
- super_constructor_argument_values (_.fuse constructor_argumentsG)
- super_constructorT (/type.method [(list)
- (list#each product.left constructor_argumentsS)
- /type.void
- (list)])
- argumentsT (list#each product.right arguments)
- initialize_object! (is Inst
- (|>> (_.ALOAD 0)
- super_constructor_argument_values
- (_.INVOKESPECIAL super_class ..constructor_name super_constructorT)))]]
- (in (def.method (..visibility privacy)
- (if strict_floating_point?
- jvm.strictM
- jvm.noneM)
- ..constructor_name
- (/type.method [method_tvars argumentsT /type.void exceptions])
- (|>> initialize_object!
- (//G.prepare_arguments 1 argumentsT)
- bodyG
- _.RETURN)))))))
-
-(def: (override_method_generation archive method)
- (-> Archive (Override Synthesis) (Operation jvm.Def))
- (do [! phase.monad]
- [.let [[[super_name super_tvars] method_name strict_floating_point? annotations
- method_tvars self arguments returnJ exceptionsJ
- bodyS] method]
- generate directive.generation]
- (directive.lifted_generation
- (do !
- [bodyG (generate archive (//G.hidden_method_body (list.size arguments) bodyS))
- .let [argumentsT (list#each product.right arguments)]]
- (in (def.method {jvm.#Public}
- (if strict_floating_point?
- jvm.strictM
- jvm.noneM)
- method_name
- (/type.method [method_tvars argumentsT returnJ exceptionsJ])
- (|>> (//G.prepare_arguments 1 argumentsT)
- bodyG
- (//G.returnI returnJ))))))))
-
-(def: (virtual_method_generation archive method)
- (-> Archive (Virtual Synthesis) (Operation jvm.Def))
- (do [! phase.monad]
- [.let [[method_name privacy final? strict_floating_point? annotations method_tvars
- self arguments returnJ exceptionsJ
- bodyS] method]
- generate directive.generation]
- (directive.lifted_generation
- (do !
- [bodyG (generate archive (//G.hidden_method_body (list.size arguments) bodyS))
- .let [argumentsT (list#each product.right arguments)]]
- (in (def.method (..visibility privacy)
- (|> jvm.noneM
- (jvm.++M (if strict_floating_point?
- jvm.strictM
- jvm.noneM))
- (jvm.++M (if final?
- jvm.finalM
- jvm.noneM)))
- method_name
- (/type.method [method_tvars argumentsT returnJ exceptionsJ])
- (|>> (//G.prepare_arguments 1 argumentsT)
- bodyG
- (//G.returnI returnJ))))))))
-
-(def: (static_method_generation archive method)
- (-> Archive (Static Synthesis) (Operation jvm.Def))
- (do [! phase.monad]
- [.let [[method_name privacy strict_floating_point? annotations method_tvars
- arguments returnJ exceptionsJ
- bodyS] method]
- generate directive.generation]
- (directive.lifted_generation
- (do !
- [bodyG (generate archive (//G.hidden_method_body (list.size arguments) bodyS))
- .let [argumentsT (list#each product.right arguments)]]
- (in (def.method (..visibility privacy)
- (|> jvm.staticM
- (jvm.++M (if strict_floating_point?
- jvm.strictM
- jvm.noneM)))
- method_name
- (/type.method [method_tvars argumentsT returnJ exceptionsJ])
- (|>> (//G.prepare_arguments 0 argumentsT)
- bodyG
- (//G.returnI returnJ))))))))
-
-(def: (method_generation archive super_class method)
- (-> Archive (Type Class) (Method Synthesis) (Operation jvm.Def))
- (case method
- {#Constructor method}
- (..constructor_method_generation archive super_class method)
-
- {#Override method}
- (..override_method_generation archive method)
-
- {#Virtual method}
- (..virtual_method_generation archive method)
-
- {#Static method}
- (..static_method_generation archive method)
-
- {#Abstract method}
- (# phase.monad in (..abstract_method_generation method))
- ))
-
-(import: java/lang/ClassLoader)
-
-(def: (convert_overriden_method method)
- (-> (Method Code) (Maybe (//A.Overriden_Method Code)))
- (case method
- {#Override [[parent_name parent_variables] method_name strict_floating_point? annotations variables
- self arguments return exceptions
- body]}
- {.#Some [(/type.class parent_name parent_variables) method_name
- strict_floating_point? (list) variables
- self arguments return exceptions
- body]}
-
- _
- {.#None}))
-
-(def: (jvm::class class_loader)
- (-> java/lang/ClassLoader ..Handler)
- (..custom
- [($_ <>.and
- ..class_declaration
- ..class
- (<code>.tuple (<>.some ..class))
- ..inheritance
- (<code>.tuple (<>.some ..annotation))
- (<code>.tuple (<>.some ..field))
- (<code>.tuple (<>.some ..method)))
- (function (_ extension_name phase archive
- [declaration
- super_class
- super_interfaces
- inheritance
- annotations
- fields
- methodsC])
- (do [! phase.monad]
- [.let [[class_name type_variables] declaration
- header (..header [class_name type_variables]
- super_class
- super_interfaces
- inheritance
- fields
- methodsC)]
- ... Necessary for reflection to work properly during analysis.
- _ (directive.lifted_generation
- (generation.execute! header))
- .let [supers (is (List (Type Class))
- (list& super_class super_interfaces))]
- _ (|> methodsC
- (list.all ..convert_overriden_method)
- (//A.require_complete_method_concretion class_loader supers)
- directive.lifted_analysis)
- methodsA (monad.each ! (method_analysis archive declaration supers) methodsC)
- methodsS (monad.each ! (method_synthesis archive) methodsA)
- methodsG (monad.each ! (method_generation archive super_class) methodsS)
- all_dependencies (|> methodsS
- (monad.each ! (method_dependencies archive))
- (# ! each cache.all)
- directive.lifted_generation)
- .let [directive [class_name
- (def.class {jvm.#V1_6} {jvm.#Public} jvm.noneC class_name
- (list#each ..constraint type_variables)
- super_class
- super_interfaces
- (def.fuse (list#composite (list#each ..field_header fields)
- methodsG)))]]]
- (directive.lifted_generation
- (do !
- [artifact_id (generation.learn_custom class_name all_dependencies)
- _ (generation.execute! directive)
- _ (generation.save! artifact_id {.#Some class_name} directive)
- _ (generation.log! (format "JVM Class " (%.text class_name)))]
- (in directive.no_requirements)))))]))
-
-(def: jvm::class::interface
- ..Handler
- (..custom
- [($_ <>.and
- ..class_declaration
- (<code>.tuple (<>.some ..class))
- (<code>.tuple (<>.some ..annotation))
- (<>.some ..method_declaration))
- (function (_ extension_name phase archive [[class_name type_variables] supers annotations method_declarations])
- (do [! phase.monad]
- [.let [directive [class_name
- (def.interface {jvm.#V1_6} {jvm.#Public} jvm.noneC class_name
- (list#each ..constraint type_variables)
- supers
- (|> method_declarations
- (list#each (function (_ (open "_[0]"))
- (def.abstract_method {jvm.#Public} jvm.noneM _#name
- (/type.method [_#type_variables _#arguments _#return _#exceptions]))))
- def.fuse))]]]
- (directive.lifted_generation
- (do !
- [artifact_id (generation.learn_custom class_name unit.none)
- _ (generation.execute! directive)
- _ (generation.save! artifact_id {.#Some class_name} directive)
- _ (generation.log! (format "JVM Interface " (%.text class_name)))]
- (in directive.no_requirements)))))]))
-
-(def: .public (bundle class_loader extender)
- (-> java/lang/ClassLoader jvm.Extender (directive.Bundle jvm.Anchor jvm.Inst jvm.Definition))
- (|> bundle.empty
- (dictionary.has "lux def generation" (..def::generation extender))
- (dictionary.has "jvm class" (..jvm::class class_loader))
- (dictionary.has "jvm class interface" ..jvm::class::interface)))
diff --git a/lux-jvm/source/luxc/lang/host/jvm.lux b/lux-jvm/source/luxc/lang/host/jvm.lux
deleted file mode 100644
index 22d901d51..000000000
--- a/lux-jvm/source/luxc/lang/host/jvm.lux
+++ /dev/null
@@ -1,150 +0,0 @@
-(.using
- [library
- [lux {"-" Definition Type Label}
- [ffi {"+" import:}]
- [abstract
- monad]
- [control
- ["<>" parser
- ["<[0]>" code]]]
- [data
- [binary {"+" Binary}]
- [text
- ["%" format {"+" format}]]
- [collection
- ["[0]" list ("[1]#[0]" monad)]]]
- [macro
- ["[0]" code]
- [syntax {"+" syntax:}]]
- [target
- [jvm
- ["[0]" type {"+" Type}
- [category {"+" Class}]]]]
- [tool
- [compiler
- [reference
- [variable {"+" Register}]]
- [language
- [lux
- ["[0]" generation]]]
- [meta
- [archive {"+" Archive}]]]]]])
-
-(import: org/objectweb/asm/MethodVisitor
- "[1]::[0]")
-
-(import: org/objectweb/asm/ClassWriter
- "[1]::[0]")
-
-(import: org/objectweb/asm/Label
- "[1]::[0]"
- (new []))
-
-(type: .public Def
- (-> org/objectweb/asm/ClassWriter org/objectweb/asm/ClassWriter))
-
-(type: .public Inst
- (-> org/objectweb/asm/MethodVisitor org/objectweb/asm/MethodVisitor))
-
-(type: .public Label
- org/objectweb/asm/Label)
-
-(type: .public Visibility
- (Variant
- {#Public}
- {#Protected}
- {#Private}
- {#Default}))
-
-(type: .public Version
- (Variant
- {#V1_1}
- {#V1_2}
- {#V1_3}
- {#V1_4}
- {#V1_5}
- {#V1_6}
- {#V1_7}
- {#V1_8}))
-
-(type: .public ByteCode
- Binary)
-
-(type: .public Definition
- [Text ByteCode])
-
-(type: .public Anchor
- [Label Register])
-
-(type: .public Host
- (generation.Host Inst Definition))
-
-(template [<name> <base>]
- [(type: .public <name>
- (<base> ..Anchor ..Inst ..Definition))]
-
- [State generation.State]
- [Operation generation.Operation]
- [Phase generation.Phase]
- [Handler generation.Handler]
- [Bundle generation.Bundle]
- [Extender generation.Extender]
- )
-
-(type: .public (Generator i)
- (-> Phase Archive i (Operation Inst)))
-
-(syntax: (config: [type <code>.local
- none <code>.local
- ++ <code>.local
- options (<code>.tuple (<>.many <code>.local))])
- (let [g!type (code.local type)
- g!none (code.local none)
- g!tags+ (list#each (|>> (format "#") code.local) options)
- g!_left (code.local "_left")
- g!_right (code.local "_right")
- g!options+ (list#each (function (_ option)
- (` (def: .public (~ (code.local option))
- (~ g!type)
- (|> (~ g!none)
- (has (~ (code.local (format "#" option))) #1)))))
- options)]
- (in (list& (` (type: .public (~ g!type)
- (.Record
- (~ (|> g!tags+
- (list#each (function (_ tag)
- (list tag (` .Bit))))
- list#conjoint
- code.tuple)))))
-
- (` (def: .public (~ g!none)
- (~ g!type)
- (~ (|> g!tags+
- (list#each (function (_ tag)
- (list tag (` #0))))
- list#conjoint
- code.tuple))))
-
- (` (def: .public ((~ (code.local ++)) (~ g!_left) (~ g!_right))
- (-> (~ g!type) (~ g!type) (~ g!type))
- (~ (|> g!tags+
- (list#each (function (_ tag)
- (list tag (` (or (the (~ tag) (~ g!_left))
- (the (~ tag) (~ g!_right)))))))
- list#conjoint
- code.tuple))))
-
- g!options+))))
-
-(config: Class_Config noneC ++C [finalC])
-(config: Method_Config noneM ++M [finalM staticM synchronizedM strictM])
-(config: Field_Config noneF ++F [finalF staticF transientF volatileF])
-
-(def: .public new_label
- (-> Any Label)
- (function (_ _)
- (org/objectweb/asm/Label::new)))
-
-(def: .public (simple_class name)
- (-> Text (Type Class))
- (type.class name (list)))
diff --git a/lux-jvm/source/luxc/lang/host/jvm/def.lux b/lux-jvm/source/luxc/lang/host/jvm/def.lux
deleted file mode 100644
index fd79d2119..000000000
--- a/lux-jvm/source/luxc/lang/host/jvm/def.lux
+++ /dev/null
@@ -1,306 +0,0 @@
-(.using
- [library
- [lux {"-" Type}
- ["[0]" ffi {"+" import: do_to}]
- [control
- ["[0]" function]]
- [data
- ["[0]" product]
- ["[0]" text
- ["%" format {"+" format}]]
- [collection
- ["[0]" array {"+" Array}]
- ["[0]" list ("[1]@[0]" functor)]]]
- [math
- [number
- ["i" int]]]
- [target
- [jvm
- [encoding
- ["[0]" name]]
- ["[0]" type {"+" Type Constraint}
- [category {"+" Class Value Method}]
- ["[0]" signature]
- ["[0]" descriptor]]]]]]
- ["[0]" //])
-
-(def: signature (|>> type.signature signature.signature))
-(def: descriptor (|>> type.descriptor descriptor.descriptor))
-(def: class_name (|>> type.descriptor descriptor.class_name name.read))
-
-(import: java/lang/Object
- "[1]::[0]")
-
-(import: java/lang/String
- "[1]::[0]")
-
-(import: org/objectweb/asm/Opcodes
- "[1]::[0]"
- ("static" ACC_PUBLIC int)
- ("static" ACC_PROTECTED int)
- ("static" ACC_PRIVATE int)
-
- ("static" ACC_TRANSIENT int)
- ("static" ACC_VOLATILE int)
-
- ("static" ACC_ABSTRACT int)
- ("static" ACC_FINAL int)
- ("static" ACC_STATIC int)
- ("static" ACC_SYNCHRONIZED int)
- ("static" ACC_STRICT int)
-
- ("static" ACC_SUPER int)
- ("static" ACC_INTERFACE int)
-
- ("static" V1_1 int)
- ("static" V1_2 int)
- ("static" V1_3 int)
- ("static" V1_4 int)
- ("static" V1_5 int)
- ("static" V1_6 int)
- ("static" V1_7 int)
- ("static" V1_8 int))
-
-(import: org/objectweb/asm/FieldVisitor
- "[1]::[0]"
- (visitEnd [] void))
-
-(import: org/objectweb/asm/MethodVisitor
- "[1]::[0]"
- (visitCode [] void)
- (visitMaxs [int int] void)
- (visitEnd [] void))
-
-(import: org/objectweb/asm/ClassWriter
- "[1]::[0]"
- ("static" COMPUTE_MAXS int)
- ("static" COMPUTE_FRAMES int)
- (new [int])
- (visit [int int java/lang/String java/lang/String java/lang/String [java/lang/String]] void)
- (visitEnd [] void)
- (visitField [int java/lang/String java/lang/String java/lang/String java/lang/Object] org/objectweb/asm/FieldVisitor)
- (visitMethod [int java/lang/String java/lang/String java/lang/String [java/lang/String]] org/objectweb/asm/MethodVisitor)
- (toByteArray [] [byte]))
-
-(def: (string_array values)
- (-> (List Text) (Array Text))
- (let [output (ffi.array java/lang/String (list.size values))]
- (exec (list@each (function (_ [idx value])
- (ffi.write! idx value output))
- (list.enumeration values))
- output)))
-
-(def: (version_flag version)
- (-> //.Version Int)
- (case version
- {//.#V1_1} (org/objectweb/asm/Opcodes::V1_1)
- {//.#V1_2} (org/objectweb/asm/Opcodes::V1_2)
- {//.#V1_3} (org/objectweb/asm/Opcodes::V1_3)
- {//.#V1_4} (org/objectweb/asm/Opcodes::V1_4)
- {//.#V1_5} (org/objectweb/asm/Opcodes::V1_5)
- {//.#V1_6} (org/objectweb/asm/Opcodes::V1_6)
- {//.#V1_7} (org/objectweb/asm/Opcodes::V1_7)
- {//.#V1_8} (org/objectweb/asm/Opcodes::V1_8)))
-
-(def: (visibility_flag visibility)
- (-> //.Visibility Int)
- (case visibility
- {//.#Public} (org/objectweb/asm/Opcodes::ACC_PUBLIC)
- {//.#Protected} (org/objectweb/asm/Opcodes::ACC_PROTECTED)
- {//.#Private} (org/objectweb/asm/Opcodes::ACC_PRIVATE)
- {//.#Default} +0))
-
-(def: (class_flags config)
- (-> //.Class_Config Int)
- ($_ i.+
- (if (the //.#finalC config) (org/objectweb/asm/Opcodes::ACC_FINAL) +0)))
-
-(def: (method_flags config)
- (-> //.Method_Config Int)
- ($_ i.+
- (if (the //.#staticM config) (org/objectweb/asm/Opcodes::ACC_STATIC) +0)
- (if (the //.#finalM config) (org/objectweb/asm/Opcodes::ACC_FINAL) +0)
- (if (the //.#synchronizedM config) (org/objectweb/asm/Opcodes::ACC_SYNCHRONIZED) +0)
- (if (the //.#strictM config) (org/objectweb/asm/Opcodes::ACC_STRICT) +0)))
-
-(def: (field_flags config)
- (-> //.Field_Config Int)
- ($_ i.+
- (if (the //.#staticF config) (org/objectweb/asm/Opcodes::ACC_STATIC) +0)
- (if (the //.#finalF config) (org/objectweb/asm/Opcodes::ACC_FINAL) +0)
- (if (the //.#transientF config) (org/objectweb/asm/Opcodes::ACC_TRANSIENT) +0)
- (if (the //.#volatileF config) (org/objectweb/asm/Opcodes::ACC_VOLATILE) +0)))
-
-(def: param_signature
- (-> (Type Class) Text)
- (|>> ..signature (format ":")))
-
-(def: (formal_param [name super interfaces])
- (-> Constraint Text)
- (format name
- (param_signature super)
- (|> interfaces
- (list@each param_signature)
- (text.interposed ""))))
-
-(def: (constraints_signature constraints super interfaces)
- (-> (List Constraint) (Type Class) (List (Type Class))
- Text)
- (let [formal_params (if (list.empty? constraints)
- ""
- (format "<"
- (|> constraints
- (list@each formal_param)
- (text.interposed ""))
- ">"))]
- (format formal_params
- (..signature super)
- (|> interfaces
- (list@each ..signature)
- (text.interposed "")))))
-
-(def: class_computes
- Int
- ($_ i.+
- (org/objectweb/asm/ClassWriter::COMPUTE_MAXS)
- ... (org/objectweb/asm/ClassWriter::COMPUTE_FRAMES)
- ))
-
-(def: binary_name (|>> name.internal name.read))
-
-(template [<name> <flag>]
- [(def: .public (<name> version visibility config name constraints super interfaces
- definitions)
- (-> //.Version //.Visibility //.Class_Config Text (List Constraint) (Type Class) (List (Type Class)) //.Def
- (ffi.type [byte]))
- (let [writer (|> (do_to (org/objectweb/asm/ClassWriter::new class_computes)
- (org/objectweb/asm/ClassWriter::visit (version_flag version)
- ($_ i.+
- (org/objectweb/asm/Opcodes::ACC_SUPER)
- <flag>
- (visibility_flag visibility)
- (class_flags config))
- (..binary_name name)
- (constraints_signature constraints super interfaces)
- (..class_name super)
- (|> interfaces
- (list@each ..class_name)
- string_array)))
- definitions)
- _ (org/objectweb/asm/ClassWriter::visitEnd writer)]
- (org/objectweb/asm/ClassWriter::toByteArray writer)))]
-
- [class +0]
- [abstract (org/objectweb/asm/Opcodes::ACC_ABSTRACT)]
- )
-
-(def: $Object
- (Type Class)
- (type.class "java.lang.Object" (list)))
-
-(def: .public (interface version visibility config name constraints interfaces
- definitions)
- (-> //.Version //.Visibility //.Class_Config Text (List Constraint) (List (Type Class)) //.Def
- (ffi.type [byte]))
- (let [writer (|> (do_to (org/objectweb/asm/ClassWriter::new class_computes)
- (org/objectweb/asm/ClassWriter::visit (version_flag version)
- ($_ i.+
- (org/objectweb/asm/Opcodes::ACC_ABSTRACT)
- (org/objectweb/asm/Opcodes::ACC_INTERFACE)
- (visibility_flag visibility)
- (class_flags config))
- (..binary_name name)
- (constraints_signature constraints $Object interfaces)
- (..class_name $Object)
- (|> interfaces
- (list@each ..class_name)
- string_array)))
- definitions)
- _ (org/objectweb/asm/ClassWriter::visitEnd writer)]
- (org/objectweb/asm/ClassWriter::toByteArray writer)))
-
-(def: .public (method visibility config name type then)
- (-> //.Visibility //.Method_Config Text (Type Method) //.Inst
- //.Def)
- (function (_ writer)
- (let [=method (org/objectweb/asm/ClassWriter::visitMethod ($_ i.+
- (visibility_flag visibility)
- (method_flags config))
- (..binary_name name)
- (..descriptor type)
- (..signature type)
- (string_array (list))
- writer)
- _ (org/objectweb/asm/MethodVisitor::visitCode =method)
- _ (then =method)
- _ (org/objectweb/asm/MethodVisitor::visitMaxs +0 +0 =method)
- _ (org/objectweb/asm/MethodVisitor::visitEnd =method)]
- writer)))
-
-(def: .public (abstract_method visibility config name type)
- (-> //.Visibility //.Method_Config Text (Type Method)
- //.Def)
- (function (_ writer)
- (let [=method (org/objectweb/asm/ClassWriter::visitMethod ($_ i.+
- (visibility_flag visibility)
- (method_flags config)
- (org/objectweb/asm/Opcodes::ACC_ABSTRACT))
- (..binary_name name)
- (..descriptor type)
- (..signature type)
- (string_array (list))
- writer)
- _ (org/objectweb/asm/MethodVisitor::visitEnd =method)]
- writer)))
-
-(def: .public (field visibility config name type)
- (-> //.Visibility //.Field_Config Text (Type Value) //.Def)
- (function (_ writer)
- (let [=field (do_to (org/objectweb/asm/ClassWriter::visitField ($_ i.+
- (visibility_flag visibility)
- (field_flags config))
- (..binary_name name)
- (..descriptor type)
- (..signature type)
- (ffi.null)
- writer)
- (org/objectweb/asm/FieldVisitor::visitEnd))]
- writer)))
-
-(template [<name> <lux_type> <jvm_type> <prepare>]
- [(def: .public (<name> visibility config name value)
- (-> //.Visibility //.Field_Config Text <lux_type> //.Def)
- (function (_ writer)
- (let [=field (do_to (org/objectweb/asm/ClassWriter::visitField ($_ i.+
- (visibility_flag visibility)
- (field_flags config))
- (..binary_name name)
- (..descriptor <jvm_type>)
- (..signature <jvm_type>)
- (<prepare> value)
- writer)
- (org/objectweb/asm/FieldVisitor::visitEnd))]
- writer)))]
-
- [boolean_field Bit type.boolean function.identity]
- [byte_field Int type.byte ffi.long_to_byte]
- [short_field Int type.short ffi.long_to_short]
- [int_field Int type.int ffi.long_to_int]
- [long_field Int type.long function.identity]
- [float_field Frac type.float ffi.double_to_float]
- [double_field Frac type.double function.identity]
- [char_field Nat type.char (|>> .int ffi.long_to_int ffi.int_to_char)]
- [string_field Text (type.class "java.lang.String" (list)) function.identity]
- )
-
-(def: .public (fuse defs)
- (-> (List //.Def) //.Def)
- (case defs
- {.#End}
- function.identity
-
- {.#Item singleton {.#End}}
- singleton
-
- {.#Item head tail}
- (function.composite (fuse tail) head)))
diff --git a/lux-jvm/source/luxc/lang/host/jvm/inst.lux b/lux-jvm/source/luxc/lang/host/jvm/inst.lux
deleted file mode 100644
index 77acf5b35..000000000
--- a/lux-jvm/source/luxc/lang/host/jvm/inst.lux
+++ /dev/null
@@ -1,472 +0,0 @@
-(.using
- [library
- [lux {"-" Type Primitive int char try}
- ["[0]" ffi {"+" import: do_to}]
- [abstract
- [monad {"+" do}]]
- [control
- ["[0]" function]
- ["[0]" maybe]
- ["[0]" try]
- ["p" parser
- ["s" code]]]
- [data
- ["[0]" product]
- [collection
- ["[0]" list ("[1]@[0]" functor)]]]
- [macro
- [syntax {"+" syntax:}]
- ["[0]" code]
- ["[0]" template]]
- [math
- [number
- ["n" nat]
- ["i" int]]]
- [target
- [jvm
- [encoding
- ["[0]" name {"+" External}]]
- ["[0]" type {"+" Type} ("[1]@[0]" equivalence)
- [category {"+" Void Value Return Method Primitive Object Class Array Var Parameter}]
- ["[0]" box]
- ["[0]" descriptor]
- ["[0]" reflection]]]]
- [tool
- [compiler
- [phase {"+" Operation}]]]]]
- ["[0]" // {"+" Inst}])
-
-(def: class_name (|>> type.descriptor descriptor.class_name name.read))
-(def: descriptor (|>> type.descriptor descriptor.descriptor))
-(def: reflection (|>> type.reflection reflection.reflection))
-
-... [Host]
-(import: java/lang/Object
- "[1]::[0]")
-
-(import: java/lang/String
- "[1]::[0]")
-
-(syntax: (declare [codes (p.many s.local)])
- (|> codes
- (list@each (function (_ code) (` ((~' "static") (~ (code.local code)) (~' int)))))
- in))
-
-(`` (import: org/objectweb/asm/Opcodes
- "[1]::[0]"
- ("static" NOP int)
-
- ... Conversion
- (~~ (declare D2F D2I D2L
- F2D F2I F2L
- I2B I2C I2D I2F I2L I2S
- L2D L2F L2I))
-
- ... Primitive
- (~~ (declare T_BOOLEAN T_CHAR T_FLOAT T_DOUBLE
- T_BYTE T_SHORT T_INT T_LONG))
-
- ... Class
- (~~ (declare CHECKCAST NEW INSTANCEOF))
-
- ... Stack
- (~~ (declare DUP DUP_X1 DUP_X2
- DUP2 DUP2_X1 DUP2_X2
- POP POP2
- SWAP))
-
- ... Jump
- (~~ (declare IF_ICMPEQ IF_ICMPGT IF_ICMPLT
- IF_ICMPNE IF_ICMPGE IF_ICMPLE
- IF_ACMPEQ IF_ACMPNE IFNULL IFNONNULL
- IFEQ IFNE IFLT IFLE IFGT IFGE
- GOTO))
-
- (~~ (declare BIPUSH SIPUSH))
- (~~ (declare ICONST_M1 ICONST_0 ICONST_1 ICONST_2 ICONST_3 ICONST_4 ICONST_5
- LCONST_0 LCONST_1
- FCONST_0 FCONST_1 FCONST_2
- DCONST_0 DCONST_1))
- ("static" ACONST_NULL int)
-
- ... Var
- (~~ (declare IINC
- ILOAD LLOAD FLOAD DLOAD ALOAD
- ISTORE LSTORE FSTORE DSTORE ASTORE))
-
- ... Arithmetic
- (~~ (declare IADD ISUB IMUL IDIV IREM INEG
- LADD LSUB LMUL LDIV LREM LNEG LCMP
- FADD FSUB FMUL FDIV FREM FNEG FCMPG FCMPL
- DADD DSUB DMUL DDIV DREM DNEG DCMPG DCMPL))
-
- ... Bit-wise
- (~~ (declare IAND IOR IXOR ISHL ISHR IUSHR
- LAND LOR LXOR LSHL LSHR LUSHR))
-
- ... Array
- (~~ (declare ARRAYLENGTH NEWARRAY ANEWARRAY
- AALOAD AASTORE
- BALOAD BASTORE
- SALOAD SASTORE
- IALOAD IASTORE
- LALOAD LASTORE
- FALOAD FASTORE
- DALOAD DASTORE
- CALOAD CASTORE))
-
- ... Member
- (~~ (declare GETSTATIC PUTSTATIC GETFIELD PUTFIELD
- INVOKESTATIC INVOKESPECIAL INVOKEVIRTUAL INVOKEINTERFACE))
-
- ("static" ATHROW int)
-
- ... Concurrency
- (~~ (declare MONITORENTER MONITOREXIT))
-
- ... Return
- (~~ (declare RETURN IRETURN LRETURN FRETURN DRETURN ARETURN))
- ))
-
-(import: org/objectweb/asm/Label
- "[1]::[0]"
- (new []))
-
-(import: org/objectweb/asm/MethodVisitor
- "[1]::[0]"
- (visitCode [] void)
- (visitMaxs [int int] void)
- (visitEnd [] void)
- (visitInsn [int] void)
- (visitLdcInsn [java/lang/Object] void)
- (visitFieldInsn [int java/lang/String java/lang/String java/lang/String] void)
- (visitTypeInsn [int java/lang/String] void)
- (visitVarInsn [int int] void)
- (visitIntInsn [int int] void)
- (visitMethodInsn [int java/lang/String java/lang/String java/lang/String boolean] void)
- (visitLabel [org/objectweb/asm/Label] void)
- (visitJumpInsn [int org/objectweb/asm/Label] void)
- (visitTryCatchBlock [org/objectweb/asm/Label org/objectweb/asm/Label org/objectweb/asm/Label java/lang/String] void)
- (visitLookupSwitchInsn [org/objectweb/asm/Label [int] [org/objectweb/asm/Label]] void)
- (visitTableSwitchInsn [int int org/objectweb/asm/Label [org/objectweb/asm/Label]] void)
- )
-
-... [Insts]
-(def: .public make_label
- (All (_ s) (Operation s org/objectweb/asm/Label))
- (function (_ state)
- {try.#Success [state (org/objectweb/asm/Label::new)]}))
-
-(def: .public (with_label action)
- (All (_ a) (-> (-> org/objectweb/asm/Label a) a))
- (action (org/objectweb/asm/Label::new)))
-
-(template [<name> <type> <prepare>]
- [(def: .public (<name> value)
- (-> <type> Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitLdcInsn (<prepare> value)))))]
-
- [boolean Bit function.identity]
- [int Int ffi.long_to_int]
- [long Int function.identity]
- [double Frac function.identity]
- [char Nat (|>> .int ffi.long_to_int ffi.int_to_char)]
- [string Text function.identity]
- )
-
-(template: (!prefix short)
- [(`` ((~~ (template.symbol ["org/objectweb/asm/Opcodes::" short]))))])
-
-(template [<constant>]
- [(def: .public <constant>
- Inst
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitInsn (!prefix <constant>)))))]
-
- [ICONST_M1] [ICONST_0] [ICONST_1] [ICONST_2] [ICONST_3] [ICONST_4] [ICONST_5]
- [LCONST_0] [LCONST_1]
- [FCONST_0] [FCONST_1] [FCONST_2]
- [DCONST_0] [DCONST_1]
- )
-
-(def: .public NULL
- Inst
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitInsn (!prefix ACONST_NULL)))))
-
-(template [<constant>]
- [(def: .public (<constant> constant)
- (-> Int Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitIntInsn (!prefix <constant>) constant))))]
-
- [BIPUSH]
- [SIPUSH]
- )
-
-(template [<name>]
- [(def: .public <name>
- Inst
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitInsn (!prefix <name>)))))]
-
- [NOP]
-
- ... Stack
- [DUP] [DUP_X1] [DUP_X2] [DUP2] [DUP2_X1] [DUP2_X2]
- [POP] [POP2]
- [SWAP]
-
- ... Conversions
- [D2F] [D2I] [D2L]
- [F2D] [F2I] [F2L]
- [I2B] [I2C] [I2D] [I2F] [I2L] [I2S]
- [L2D] [L2F] [L2I]
-
- ... Integer arithmetic
- [IADD] [ISUB] [IMUL] [IDIV] [IREM] [INEG]
-
- ... Integer bitwise
- [IAND] [IOR] [IXOR] [ISHL] [ISHR] [IUSHR]
-
- ... Long arithmetic
- [LADD] [LSUB] [LMUL] [LDIV] [LREM] [LNEG]
- [LCMP]
-
- ... Long bitwise
- [LAND] [LOR] [LXOR] [LSHL] [LSHR] [LUSHR]
-
- ... Float arithmetic
- [FADD] [FSUB] [FMUL] [FDIV] [FREM] [FNEG] [FCMPG] [FCMPL]
-
- ... Double arithmetic
- [DADD] [DSUB] [DMUL] [DDIV] [DREM] [DNEG]
- [DCMPG] [DCMPL]
-
- ... Array
- [ARRAYLENGTH]
- [AALOAD] [AASTORE]
- [BALOAD] [BASTORE]
- [SALOAD] [SASTORE]
- [IALOAD] [IASTORE]
- [LALOAD] [LASTORE]
- [FALOAD] [FASTORE]
- [DALOAD] [DASTORE]
- [CALOAD] [CASTORE]
-
- ... Exceptions
- [ATHROW]
-
- ... Concurrency
- [MONITORENTER] [MONITOREXIT]
-
- ... Return
- [RETURN] [IRETURN] [LRETURN] [FRETURN] [DRETURN] [ARETURN]
- )
-
-(type: .public Register Nat)
-
-(template [<name>]
- [(def: .public (<name> register)
- (-> Register Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitVarInsn (!prefix <name>) (.int register)))))]
-
- [IINC]
- [ILOAD] [LLOAD] [FLOAD] [DLOAD] [ALOAD]
- [ISTORE] [LSTORE] [FSTORE] [DSTORE] [ASTORE]
- )
-
-(template [<name> <inst>]
- [(def: .public (<name> class field type)
- (-> (Type Class) Text (Type Value) Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitFieldInsn (<inst>) (..class_name class) field (..descriptor type)))))]
-
- [GETSTATIC org/objectweb/asm/Opcodes::GETSTATIC]
- [PUTSTATIC org/objectweb/asm/Opcodes::PUTSTATIC]
-
- [PUTFIELD org/objectweb/asm/Opcodes::PUTFIELD]
- [GETFIELD org/objectweb/asm/Opcodes::GETFIELD]
- )
-
-(template [<category> <instructions>+]
- [(`` (template [<name> <inst>]
- [(def: .public (<name> class)
- (-> (Type <category>) Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitTypeInsn (<inst>) (..class_name class)))))]
-
- (~~ (template.spliced <instructions>+))))]
-
- [Object
- [[CHECKCAST org/objectweb/asm/Opcodes::CHECKCAST]
- [ANEWARRAY org/objectweb/asm/Opcodes::ANEWARRAY]]]
-
- [Class
- [[NEW org/objectweb/asm/Opcodes::NEW]
- [INSTANCEOF org/objectweb/asm/Opcodes::INSTANCEOF]]]
- )
-
-(def: .public (NEWARRAY type)
- (-> (Type Primitive) Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitIntInsn (org/objectweb/asm/Opcodes::NEWARRAY)
- (`` (cond (~~ (template [<descriptor> <opcode>]
- [(type@= <descriptor> type) (<opcode>)]
-
- [type.boolean org/objectweb/asm/Opcodes::T_BOOLEAN]
- [type.byte org/objectweb/asm/Opcodes::T_BYTE]
- [type.short org/objectweb/asm/Opcodes::T_SHORT]
- [type.int org/objectweb/asm/Opcodes::T_INT]
- [type.long org/objectweb/asm/Opcodes::T_LONG]
- [type.float org/objectweb/asm/Opcodes::T_FLOAT]
- [type.double org/objectweb/asm/Opcodes::T_DOUBLE]
- [type.char org/objectweb/asm/Opcodes::T_CHAR]))
- ... else
- (undefined)))))))
-
-(template [<name> <inst> <interface?>]
- [(def: .public (<name> class method_name method)
- (-> (Type Class) Text (Type Method) Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitMethodInsn (<inst>)
- (..class_name class)
- method_name
- (|> method type.descriptor descriptor.descriptor)
- <interface?>))))]
-
- [INVOKESTATIC org/objectweb/asm/Opcodes::INVOKESTATIC false]
- [INVOKEVIRTUAL org/objectweb/asm/Opcodes::INVOKEVIRTUAL false]
- [INVOKESPECIAL org/objectweb/asm/Opcodes::INVOKESPECIAL false]
- [INVOKEINTERFACE org/objectweb/asm/Opcodes::INVOKEINTERFACE true]
- )
-
-(template [<name>]
- [(def: .public (<name> @where)
- (-> //.Label Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitJumpInsn (!prefix <name>) @where))))]
-
- [IF_ICMPEQ] [IF_ICMPGT] [IF_ICMPLT]
- [IF_ICMPNE] [IF_ICMPGE] [IF_ICMPLE]
- [IF_ACMPEQ] [IF_ACMPNE] [IFNULL] [IFNONNULL]
- [IFEQ] [IFNE] [IFLT] [IFLE] [IFGT] [IFGE]
- [GOTO]
- )
-
-(def: .public (LOOKUPSWITCH default keys+labels)
- (-> //.Label (List [Int //.Label]) Inst)
- (function (_ visitor)
- (let [keys+labels (list.sorted (function (_ left right)
- (i.< (product.left left) (product.left right)))
- keys+labels)
- array_size (list.size keys+labels)
- keys_array (ffi.array int array_size)
- labels_array (ffi.array org/objectweb/asm/Label array_size)
- _ (loop (again [idx 0])
- (if (n.< array_size idx)
- (let [[key label] (maybe.trusted (list.item idx keys+labels))]
- (exec
- (ffi.write! idx (ffi.long_to_int key) keys_array)
- (ffi.write! idx label labels_array)
- (again (++ idx))))
- []))]
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitLookupSwitchInsn default keys_array labels_array)))))
-
-(def: .public (TABLESWITCH min max default labels)
- (-> Int Int //.Label (List //.Label) Inst)
- (function (_ visitor)
- (let [num_labels (list.size labels)
- labels_array (ffi.array org/objectweb/asm/Label num_labels)
- _ (loop (again [idx 0])
- (if (n.< num_labels idx)
- (exec (ffi.write! idx
- (maybe.trusted (list.item idx labels))
- labels_array)
- (again (++ idx)))
- []))]
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitTableSwitchInsn min max default labels_array)))))
-
-(def: .public (try @from @to @handler exception)
- (-> //.Label //.Label //.Label (Type Class) Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitTryCatchBlock @from @to @handler (..class_name exception)))))
-
-(def: .public (label @label)
- (-> //.Label Inst)
- (function (_ visitor)
- (do_to visitor
- (org/objectweb/asm/MethodVisitor::visitLabel @label))))
-
-(def: .public (array elementT)
- (-> (Type Value) Inst)
- (case (type.primitive? elementT)
- {.#Left elementT}
- (ANEWARRAY elementT)
-
- {.#Right elementT}
- (NEWARRAY elementT)))
-
-(template [<name> <boolean> <byte> <short> <int> <long> <float> <double> <char>]
- [(def: (<name> type)
- (-> (Type Primitive) Text)
- (`` (cond (~~ (template [<descriptor> <output>]
- [(type@= <descriptor> type) <output>]
-
- [type.boolean <boolean>]
- [type.byte <byte>]
- [type.short <short>]
- [type.int <int>]
- [type.long <long>]
- [type.float <float>]
- [type.double <double>]
- [type.char <char>]))
- ... else
- (undefined))))]
-
- [primitive_wrapper
- box.boolean box.byte box.short box.int
- box.long box.float box.double box.char]
- [primitive_unwrap
- "booleanValue" "byteValue" "shortValue" "intValue"
- "longValue" "floatValue" "doubleValue" "charValue"]
- )
-
-(def: .public (wrap type)
- (-> (Type Primitive) Inst)
- (let [wrapper (type.class (primitive_wrapper type) (list))]
- (INVOKESTATIC wrapper "valueOf" (type.method [(list) (list type) wrapper (list)]))))
-
-(def: .public (unwrap type)
- (-> (Type Primitive) Inst)
- (let [wrapper (type.class (primitive_wrapper type) (list))]
- (|>> (CHECKCAST wrapper)
- (INVOKEVIRTUAL wrapper (primitive_unwrap type) (type.method [(list) (list) type (list)])))))
-
-(def: .public (fuse insts)
- (-> (List Inst) Inst)
- (case insts
- {.#End}
- function.identity
-
- {.#Item singleton {.#End}}
- singleton
-
- {.#Item head tail}
- (function.composite (fuse tail) head)))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm.lux b/lux-jvm/source/luxc/lang/translation/jvm.lux
deleted file mode 100644
index b9ec15962..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm.lux
+++ /dev/null
@@ -1,202 +0,0 @@
-(.using
- [library
- [lux {"-" Definition}
- ["[0]" ffi {"+" import: do_to object}]
- [abstract
- [monad {"+" do}]]
- [control
- pipe
- ["[0]" maybe]
- ["[0]" try {"+" Try}]
- ["[0]" exception {"+" exception:}]
- ["[0]" io {"+" IO io}]
- [concurrency
- ["[0]" atom {"+" Atom atom}]]]
- [data
- [binary {"+" Binary}]
- ["[0]" product]
- ["[0]" text ("[1]@[0]" hash)
- ["%" format {"+" format}]]
- [collection
- ["[0]" array]
- ["[0]" dictionary {"+" Dictionary}]]]
- [target
- [jvm
- ["[0]" loader {"+" Library}]
- ["[0]" type
- ["[0]" descriptor]]]]
- [tool
- [compiler
- [language
- [lux
- ["[0]" version]]]
- [meta
- [io {"+" lux_context}]
- [archive
- ["[0]" unit]]]]]]]
- [///
- [host
- ["[0]" jvm {"+" Inst Definition Host State}
- ["[0]" def]
- ["[0]" inst]]]]
- )
-
-(import: java/lang/reflect/Field
- "[1]::[0]"
- (get ["?" java/lang/Object] "try" "?" java/lang/Object))
-
-(import: (java/lang/Class a)
- "[1]::[0]"
- (getField [java/lang/String] "try" java/lang/reflect/Field))
-
-(import: java/lang/Object
- "[1]::[0]"
- (getClass [] (java/lang/Class java/lang/Object)))
-
-(import: java/lang/ClassLoader
- "[1]::[0]")
-
-(type: .public ByteCode Binary)
-
-(def: .public value_field Text "_value")
-(def: .public $Value (type.class "java.lang.Object" (list)))
-
-(exception: .public (cannot_load [class Text
- error Text])
- (exception.report
- "Class" class
- "Error" error))
-
-(exception: .public (invalid_field [class Text
- field Text
- error Text])
- (exception.report
- "Class" class
- "Field" field
- "Error" error))
-
-(exception: .public (invalid_value [class Text])
- (exception.report
- "Class" class))
-
-(def: (class_value class_name class)
- (-> Text (java/lang/Class java/lang/Object) (Try Any))
- (case (java/lang/Class::getField ..value_field class)
- {try.#Success field}
- (case (java/lang/reflect/Field::get {.#None} field)
- {try.#Success ?value}
- (case ?value
- {.#Some value}
- {try.#Success value}
-
- {.#None}
- (exception.except ..invalid_value class_name))
-
- {try.#Failure error}
- (exception.except ..cannot_load [class_name error]))
-
- {try.#Failure error}
- (exception.except ..invalid_field [class_name ..value_field error])))
-
-(def: class_path_separator ".")
-
-(def: .public bytecode_name
- (-> Text Text)
- (text.replaced ..class_path_separator .module_separator))
-
-(def: .public (class_name [module_id artifact_id])
- (-> unit.ID Text)
- (format lux_context
- ..class_path_separator (%.nat version.version)
- ..class_path_separator (%.nat module_id)
- ..class_path_separator (%.nat artifact_id)))
-
-(def: (evaluate! library loader eval_class valueI)
- (-> Library java/lang/ClassLoader Text Inst (Try [Any Definition]))
- (let [bytecode_name (..bytecode_name eval_class)
- bytecode (def.class {jvm.#V1_6}
- {jvm.#Public} jvm.noneC
- bytecode_name
- (list) $Value
- (list)
- (|>> (def.field {jvm.#Public} ($_ jvm.++F jvm.finalF jvm.staticF)
- ..value_field ..$Value)
- (def.method {jvm.#Public} ($_ jvm.++M jvm.staticM jvm.strictM)
- "<clinit>"
- (type.method [(list) (list) type.void (list)])
- (|>> valueI
- (inst.PUTSTATIC (type.class bytecode_name (list)) ..value_field ..$Value)
- inst.RETURN))))]
- (io.run! (do (try.with io.monad)
- [_ (loader.store eval_class bytecode library)
- class (loader.load eval_class loader)
- value (# io.monad in (..class_value eval_class class))]
- (in [value
- [eval_class bytecode]])))))
-
-(def: (execute! library loader [class_name class_bytecode])
- (-> Library java/lang/ClassLoader Definition (Try Any))
- (io.run! (do (try.with io.monad)
- [existing_class? (|> (atom.read! library)
- (# io.monad each (function (_ library)
- (dictionary.key? library class_name)))
- (try.lifted io.monad)
- (is (IO (Try Bit))))
- _ (if existing_class?
- (in [])
- (loader.store class_name class_bytecode library))]
- (loader.load class_name loader))))
-
-(def: (define! library loader context custom valueI)
- (-> Library java/lang/ClassLoader unit.ID (Maybe Text) Inst (Try [Text Any Definition]))
- (do try.monad
- [[value definition] (evaluate! library loader (..class_name context) valueI)]
- (in [(maybe.else (..class_name context)
- custom)
- value definition])))
-
-(def: .public host
- (IO [java/lang/ClassLoader Host])
- (io (let [library (loader.new_library [])
- loader (loader.memory library)]
- [loader
- (is Host
- (implementation
- (def: (evaluate context valueI)
- (# try.monad each product.left
- (..evaluate! library loader (format "E" (..class_name context)) valueI)))
-
- (def: execute
- (..execute! library loader))
-
- (def: define
- (..define! library loader))
-
- (def: (ingest context bytecode)
- [(..class_name context) bytecode])
-
- (def: (re_learn context custom [_ bytecode])
- (io.run!
- (loader.store (maybe.else (..class_name context) custom) bytecode library)))
-
- (def: (re_load context custom [directive_name bytecode])
- (io.run!
- (do (try.with io.monad)
- [.let [class_name (maybe.else (..class_name context)
- custom)]
- _ (loader.store class_name bytecode library)
- class (loader.load class_name loader)]
- (# io.monad in (..class_value class_name class)))))))])))
-
-(def: .public $Variant
- (type.array ..$Value))
-
-(def: .public $Tuple
- (type.array ..$Value))
-
-(def: .public $Runtime
- (type.class (..class_name [0 0]) (list)))
-
-(def: .public $Function
- (type.class "library.lux.Function" ... (..class_name [0 1])
- (list)))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/case.lux b/lux-jvm/source/luxc/lang/translation/jvm/case.lux
deleted file mode 100644
index cb5004f83..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/case.lux
+++ /dev/null
@@ -1,301 +0,0 @@
-(.using
- [library
- [lux {"-" Type Label Primitive if exec let case}
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" function]
- ["ex" exception {"+" exception:}]]
- [data
- [collection
- ["[0]" list ("[1]@[0]" mix)]]]
- [macro
- ["^" pattern]]
- [math
- [number
- ["n" nat]]]
- [target
- [jvm
- ["[0]" type {"+" Type}
- ["[0]" category {"+" Void Value Return Primitive Object Class Array Var Parameter Method}]
- ["[0]" descriptor {"+" Descriptor}]
- ["[0]" signature {"+" Signature}]]]]
- [tool
- [compiler
- ["[0]" phase ("operation@[0]" monad)]
- [meta
- [archive {"+" Archive}]]
- [language
- [lux
- ["[0]" synthesis {"+" Path Synthesis}]]]]]]]
- [luxc
- [lang
- [host
- ["$" jvm {"+" Label Inst Operation Phase Generator}
- ["_" inst]]]]]
- ["[0]" //
- ["[0]" runtime]
- ["[0]" structure]])
-
-(def: (pop_altI stack_depth)
- (-> Nat Inst)
- (.case stack_depth
- 0 function.identity
- 1 _.POP
- 2 _.POP2
- _ ... (n.> 2)
- (|>> _.POP2
- (pop_altI (n.- 2 stack_depth)))))
-
-(def: peekI
- Inst
- (|>> _.DUP
- (_.int +0)
- _.AALOAD))
-
-(def: pushI
- Inst
- (_.INVOKESTATIC //.$Runtime "pm_push" (type.method [(list) (list runtime.$Stack //.$Value) runtime.$Stack (list)])))
-
-(def: popI
- (|>> (_.int +1)
- _.AALOAD
- (_.CHECKCAST runtime.$Stack)))
-
-(def: (leftsI value)
- (-> Nat Inst)
- (.case value
- 0 _.ICONST_0
- 1 _.ICONST_1
- 2 _.ICONST_2
- 3 _.ICONST_3
- 4 _.ICONST_4
- 5 _.ICONST_5
- _ (_.int (.int value))))
-
-(def: projectionJT
- (type.method [(list) (list //.$Tuple runtime.$Index) //.$Value (list)]))
-
-(def: (left_projection lefts)
- (-> Nat Inst)
- (.let [[indexI accessI] (.case lefts
- 0
- [_.ICONST_0
- _.AALOAD]
-
- lefts
- [(leftsI lefts)
- (_.INVOKESTATIC //.$Runtime "tuple_left" ..projectionJT)])]
- (|>> (_.CHECKCAST //.$Tuple)
- indexI
- accessI)))
-
-(def: (right_projection lefts)
- (-> Nat Inst)
- (|>> (_.CHECKCAST //.$Tuple)
- (leftsI lefts)
- (_.INVOKESTATIC //.$Runtime "tuple_right" ..projectionJT)))
-
-(def: equalsJT
- (type.method [(list) (list //.$Value) type.boolean (list)]))
-
-(def: sideJT
- (type.method [(list) (list //.$Variant runtime.$Lefts runtime.$Right?) runtime.$Value (list)]))
-
-(def: (path' stack_depth @else @end phase archive path)
- (-> Nat Label Label Phase Archive Path (Operation Inst))
- (.case path
- {synthesis.#Pop}
- (operation@in ..popI)
-
- {synthesis.#Bind register}
- (operation@in (|>> peekI
- (_.ASTORE register)))
-
- {synthesis.#Bit_Fork when thenP elseP}
- (do phase.monad
- [thenG (path' stack_depth @else @end phase archive thenP)
- elseG (.case elseP
- {.#Some elseP}
- (path' stack_depth @else @end phase archive elseP)
-
- {.#None}
- (in (_.GOTO @else)))
- .let [ifI (.if when _.IFEQ _.IFNE)]]
- (in (<| _.with_label (function (_ @else))
- (|>> peekI
- (_.unwrap type.boolean)
- (ifI @else)
- thenG
- (_.label @else)
- elseG))))
-
- (^.template [<tag> <unwrap> <dup> <pop> <test> <comparison> <if>]
- [{<tag> cons}
- (do [@ phase.monad]
- [forkG (is (Operation Inst)
- (monad.mix @ (function (_ [test thenP] elseG)
- (do @
- [thenG (path' stack_depth @else @end phase archive thenP)]
- (in (<| _.with_label (function (_ @else))
- (|>> <dup>
- (<test> test)
- <comparison>
- (<if> @else)
- <pop>
- thenG
- (_.label @else)
- elseG)))))
- (|>> <pop>
- (_.GOTO @else))
- {.#Item cons}))]
- (in (|>> peekI
- <unwrap>
- forkG)))])
- ([synthesis.#I64_Fork (_.unwrap type.long) _.DUP2 _.POP2 (|>> .int _.long) _.LCMP _.IFNE]
- [synthesis.#F64_Fork (_.unwrap type.double) _.DUP2 _.POP2 _.double _.DCMPL _.IFNE]
- [synthesis.#Text_Fork (|>) _.DUP _.POP _.string
- (_.INVOKEVIRTUAL (type.class "java.lang.Object" (list)) "equals" ..equalsJT)
- _.IFEQ])
-
- {synthesis.#Then bodyS}
- (do phase.monad
- [bodyI (phase archive bodyS)]
- (in (|>> (pop_altI stack_depth)
- bodyI
- (_.GOTO @end))))
-
- (^.template [<pattern> <right?>]
- [(pattern (<pattern> lefts))
- (operation@in (<| _.with_label (function (_ @success))
- _.with_label (function (_ @fail))
- (|>> peekI
- (_.CHECKCAST //.$Variant)
- (structure.tagI lefts <right?>)
- (structure.flagI <right?>)
- (_.INVOKESTATIC //.$Runtime "pm_variant" ..sideJT)
- _.DUP
- (_.IFNULL @fail)
- (_.GOTO @success)
- (_.label @fail)
- _.POP
- (_.GOTO @else)
- (_.label @success)
- pushI)))])
- ([synthesis.side/left false]
- [synthesis.side/right true])
-
- ... Extra optimization
- (^.template [<path> <projection>]
- [(pattern (<path> lefts))
- (operation@in (|>> peekI
- (<projection> lefts)
- pushI))
-
- (pattern (synthesis.path/seq
- (<path> lefts)
- (synthesis.!bind_top register thenP)))
- (do phase.monad
- [then! (path' stack_depth @else @end phase archive thenP)]
- (in (|>> peekI
- (<projection> lefts)
- (_.ASTORE register)
- then!)))])
- ([synthesis.member/left ..left_projection]
- [synthesis.member/right ..right_projection])
-
- {synthesis.#Seq leftP rightP}
- (do phase.monad
- [leftI (path' stack_depth @else @end phase archive leftP)
- rightI (path' stack_depth @else @end phase archive rightP)]
- (in (|>> leftI
- rightI)))
-
- {synthesis.#Alt leftP rightP}
- (do phase.monad
- [@alt_else _.make_label
- leftI (path' (++ stack_depth) @alt_else @end phase archive leftP)
- rightI (path' stack_depth @else @end phase archive rightP)]
- (in (|>> _.DUP
- leftI
- (_.label @alt_else)
- _.POP
- rightI)))
- ))
-
-(def: failJT
- (type.method [(list) (list) type.void (list)]))
-
-(def: (path @end phase archive path)
- (-> Label Phase Archive Path (Operation Inst))
- (do phase.monad
- [@else _.make_label
- pathI (..path' 1 @else @end phase archive path)]
- (in (|>> pathI
- (_.label @else)
- _.POP
- (_.INVOKESTATIC //.$Runtime "pm_fail" ..failJT)
- _.NULL
- (_.GOTO @end)))))
-
-(def: .public (if phase archive [testS thenS elseS])
- (Generator [Synthesis Synthesis Synthesis])
- (do phase.monad
- [testI (phase archive testS)
- thenI (phase archive thenS)
- elseI (phase archive elseS)]
- (in (<| _.with_label (function (_ @else))
- _.with_label (function (_ @end))
- (|>> testI
- (_.unwrap type.boolean)
- (_.IFEQ @else)
- thenI
- (_.GOTO @end)
- (_.label @else)
- elseI
- (_.label @end))))))
-
-(def: .public (exec phase archive [this that])
- (Generator [Synthesis Synthesis])
- (do phase.monad
- [this! (phase archive this)
- that! (phase archive that)]
- (in (|>> this!
- _.POP
- that!))))
-
-(def: .public (let phase archive [inputS register exprS])
- (Generator [Synthesis Nat Synthesis])
- (do phase.monad
- [inputI (phase archive inputS)
- exprI (phase archive exprS)]
- (in (|>> inputI
- (_.ASTORE register)
- exprI))))
-
-(def: .public (get phase archive [path recordS])
- (Generator [(List synthesis.Member) Synthesis])
- (do phase.monad
- [recordG (phase archive recordS)]
- (in (list@mix (function (_ step so_far)
- (.let [next (.case step
- {.#Left lefts}
- (..left_projection lefts)
-
- {.#Right lefts}
- (..right_projection lefts))]
- (|>> so_far next)))
- recordG
- (list.reversed path)))))
-
-(def: .public (case phase archive [valueS path])
- (Generator [Synthesis Path])
- (do phase.monad
- [@end _.make_label
- valueI (phase archive valueS)
- pathI (..path @end phase archive path)]
- (in (|>> _.NULL
- valueI
- pushI
- pathI
- (_.label @end)))))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/expression.lux b/lux-jvm/source/luxc/lang/translation/jvm/expression.lux
deleted file mode 100644
index 692835dc4..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/expression.lux
+++ /dev/null
@@ -1,78 +0,0 @@
-(.using
- [library
- [lux "*"
- [tool
- [compiler
- [language
- [lux
- ["[0]" synthesis]
- [phase
- ["[0]" extension]]]]]]]]
- [luxc
- [lang
- [host
- [jvm {"+" Phase}]]]]
- [//
- ["[0]" primitive]
- ["[0]" structure]
- ["[0]" reference]
- ["[0]" case]
- ["[0]" loop]
- ["[0]" function]])
-
-(def: .public (translate archive synthesis)
- Phase
- (case synthesis
- (pattern (synthesis.bit value))
- (primitive.bit value)
-
- (pattern (synthesis.i64 value))
- (primitive.i64 value)
-
- (pattern (synthesis.f64 value))
- (primitive.f64 value)
-
- (pattern (synthesis.text value))
- (primitive.text value)
-
- (pattern (synthesis.variant data))
- (structure.variant translate archive data)
-
- (pattern (synthesis.tuple members))
- (structure.tuple translate archive members)
-
- (pattern (synthesis.variable variable))
- (reference.variable archive variable)
-
- (pattern (synthesis.constant constant))
- (reference.constant archive constant)
-
- (pattern (synthesis.branch/exec it))
- (case.exec translate archive it)
-
- (pattern (synthesis.branch/let data))
- (case.let translate archive data)
-
- (pattern (synthesis.branch/if data))
- (case.if translate archive data)
-
- (pattern (synthesis.branch/get data))
- (case.get translate archive data)
-
- (pattern (synthesis.branch/case data))
- (case.case translate archive data)
-
- (pattern (synthesis.loop/again data))
- (loop.again translate archive data)
-
- (pattern (synthesis.loop/scope data))
- (loop.scope translate archive data)
-
- (pattern (synthesis.function/apply data))
- (function.call translate archive data)
-
- (pattern (synthesis.function/abstraction data))
- (function.function translate archive data)
-
- {synthesis.#Extension extension}
- (extension.apply archive translate extension)))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/extension.lux b/lux-jvm/source/luxc/lang/translation/jvm/extension.lux
deleted file mode 100644
index 997f850ca..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/extension.lux
+++ /dev/null
@@ -1,17 +0,0 @@
-(.using
- [library
- [lux "*"
- [data
- [collection
- ["[0]" dictionary]]]]]
- [////
- [host
- [jvm {"+" Bundle}]]]
- ["[0]" / "_"
- ["[1][0]" common]
- ["[1][0]" host]])
-
-(def: .public bundle
- Bundle
- (dictionary.merged /common.bundle
- /host.bundle))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/extension/common.lux b/lux-jvm/source/luxc/lang/translation/jvm/extension/common.lux
deleted file mode 100644
index 10fe4e948..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/extension/common.lux
+++ /dev/null
@@ -1,359 +0,0 @@
-(.using
- [library
- [lux {"-" Type Label}
- [ffi {"+" import:}]
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" try]
- ["<>" parser
- ["<s>" synthesis {"+" Parser}]]]
- [data
- ["[0]" product]
- [collection
- ["[0]" list ("[1]@[0]" monad)]
- ["[0]" dictionary]]]
- [math
- [number
- ["f" frac]]]
- [target
- [jvm
- ["[0]" type]]]
- [tool
- [compiler
- ["[0]" phase]
- [meta
- [archive {"+" Archive}]]
- [language
- [lux
- ["[0]" synthesis {"+" Synthesis %synthesis}]
- [phase
- [generation
- [extension {"+" Nullary Unary Binary Trinary Variadic
- nullary unary binary trinary variadic}]]
- ["[0]" extension
- ["[0]" bundle]]]]]]]]]
- [luxc
- [lang
- [host
- ["$" jvm {"+" Label Inst Def Handler Bundle Operation Phase}
- ["_" inst]]]]]
- ["[0]" ///
- ["[0]" runtime]])
-
-(def: .public (custom [parser handler])
- (All (_ s)
- (-> [(Parser s)
- (-> Text Phase Archive s (Operation Inst))]
- Handler))
- (function (_ extension_name phase archive input)
- (case (<s>.result parser input)
- {try.#Success input'}
- (handler extension_name phase archive input')
-
- {try.#Failure error}
- (phase.except extension.invalid_syntax [extension_name %synthesis input]))))
-
-(def: $String (type.class "java.lang.String" (list)))
-(def: $CharSequence (type.class "java.lang.CharSequence" (list)))
-(def: $System (type.class "java.lang.System" (list)))
-(def: $Object (type.class "java.lang.Object" (list)))
-
-(def: lux_intI Inst (|>> _.I2L (_.wrap type.long)))
-(def: jvm_intI Inst (|>> (_.unwrap type.long) _.L2I))
-(def: check_stringI Inst (_.CHECKCAST $String))
-
-(def: (predicateI tester)
- (-> (-> Label Inst)
- Inst)
- (let [$Boolean (type.class "java.lang.Boolean" (list))]
- (<| _.with_label (function (_ @then))
- _.with_label (function (_ @end))
- (|>> (tester @then)
- (_.GETSTATIC $Boolean "FALSE" $Boolean)
- (_.GOTO @end)
- (_.label @then)
- (_.GETSTATIC $Boolean "TRUE" $Boolean)
- (_.label @end)
- ))))
-
-(def: unitI Inst (_.string synthesis.unit))
-
-... TODO: Get rid of this ASAP
-(def: lux::syntax_char_case!
- (..custom [($_ <>.and
- <s>.any
- <s>.any
- (<>.some (<s>.tuple ($_ <>.and
- (<s>.tuple (<>.many <s>.i64))
- <s>.any))))
- (function (_ extension_name phase archive [input else conditionals])
- (<| _.with_label (function (_ @end))
- _.with_label (function (_ @else))
- (do [@ phase.monad]
- [inputG (phase archive input)
- elseG (phase archive else)
- conditionalsG+ (is (Operation (List [(List [Int Label])
- Inst]))
- (monad.each @ (function (_ [chars branch])
- (do @
- [branchG (phase archive branch)]
- (in (<| _.with_label (function (_ @branch))
- [(list@each (function (_ char)
- [(.int char) @branch])
- chars)
- (|>> (_.label @branch)
- branchG
- (_.GOTO @end))]))))
- conditionals))
- .let [table (|> conditionalsG+
- (list@each product.left)
- list@conjoint)
- conditionalsG (|> conditionalsG+
- (list@each product.right)
- _.fuse)]]
- (in (|>> inputG (_.unwrap type.long) _.L2I
- (_.LOOKUPSWITCH @else table)
- conditionalsG
- (_.label @else)
- elseG
- (_.label @end))))))]))
-
-(def: (lux::is [referenceI sampleI])
- (Binary Inst)
- (|>> referenceI
- sampleI
- (predicateI _.IF_ACMPEQ)))
-
-(def: (lux::try riskyI)
- (Unary Inst)
- (|>> riskyI
- (_.CHECKCAST ///.$Function)
- (_.INVOKESTATIC ///.$Runtime "try" runtime.try)))
-
-(template [<name> <op>]
- [(def: (<name> [maskI inputI])
- (Binary Inst)
- (|>> inputI (_.unwrap type.long)
- maskI (_.unwrap type.long)
- <op> (_.wrap type.long)))]
-
- [i64::and _.LAND]
- [i64::or _.LOR]
- [i64::xor _.LXOR]
- )
-
-(template [<name> <op>]
- [(def: (<name> [shiftI inputI])
- (Binary Inst)
- (|>> inputI (_.unwrap type.long)
- shiftI jvm_intI
- <op>
- (_.wrap type.long)))]
-
- [i64::left_shift _.LSHL]
- [i64::right_shift _.LUSHR]
- )
-
-(template [<name> <type> <op>]
- [(def: (<name> [paramI subjectI])
- (Binary Inst)
- (|>> subjectI (_.unwrap <type>)
- paramI (_.unwrap <type>)
- <op>
- (_.wrap <type>)))]
-
- [i64::+ type.long _.LADD]
- [i64::- type.long _.LSUB]
- [i64::* type.long _.LMUL]
- [i64::/ type.long _.LDIV]
- [i64::% type.long _.LREM]
-
- [f64::+ type.double _.DADD]
- [f64::- type.double _.DSUB]
- [f64::* type.double _.DMUL]
- [f64::/ type.double _.DDIV]
- [f64::% type.double _.DREM]
- )
-
-(template [<eq> <lt> <type> <cmp>]
- [(template [<name> <reference>]
- [(def: (<name> [paramI subjectI])
- (Binary Inst)
- (|>> subjectI (_.unwrap <type>)
- paramI (_.unwrap <type>)
- <cmp>
- (_.int <reference>)
- (predicateI _.IF_ICMPEQ)))]
-
- [<eq> +0]
- [<lt> -1])]
-
- [i64::= i64::< type.long _.LCMP]
- [f64::= f64::< type.double _.DCMPG]
- )
-
-(template [<name> <prepare> <transform>]
- [(def: (<name> inputI)
- (Unary Inst)
- (|>> inputI <prepare> <transform>))]
-
- [i64::f64 (_.unwrap type.long) (<| (_.wrap type.double) _.L2D)]
- [i64::char (_.unwrap type.long)
- ((|>> _.L2I _.I2C (_.INVOKESTATIC (type.class "java.lang.Character" (list)) "toString" (type.method [(list) (list type.char) $String (list)]))))]
-
- [f64::i64 (_.unwrap type.double) (<| (_.wrap type.long) _.D2L)]
- [f64::encode (_.unwrap type.double)
- (_.INVOKESTATIC (type.class "java.lang.Double" (list)) "toString" (type.method [(list) (list type.double) $String (list)]))]
- [f64::decode ..check_stringI
- (_.INVOKESTATIC ///.$Runtime "decode_frac" (type.method [(list) (list $String) ///.$Variant (list)]))]
- )
-
-(def: (text::size inputI)
- (Unary Inst)
- (|>> inputI
- ..check_stringI
- (_.INVOKEVIRTUAL $String "length" (type.method [(list) (list) type.int (list)]))
- lux_intI))
-
-(template [<name> <pre_subject> <pre_param> <op> <post>]
- [(def: (<name> [paramI subjectI])
- (Binary Inst)
- (|>> subjectI <pre_subject>
- paramI <pre_param>
- <op> <post>))]
-
- [text::= (<|) (<|)
- (_.INVOKEVIRTUAL $Object "equals" (type.method [(list) (list $Object) type.boolean (list)]))
- (_.wrap type.boolean)]
- [text::< ..check_stringI ..check_stringI
- (_.INVOKEVIRTUAL $String "compareTo" (type.method [(list) (list $String) type.int (list)]))
- (predicateI _.IFLT)]
- [text::char ..check_stringI jvm_intI
- (_.INVOKEVIRTUAL $String "charAt" (type.method [(list) (list type.int) type.char (list)]))
- lux_intI]
- )
-
-(def: (text::concat [leftI rightI])
- (Binary Inst)
- (|>> leftI ..check_stringI
- rightI ..check_stringI
- (_.INVOKEVIRTUAL $String "concat" (type.method [(list) (list $String) $String (list)]))))
-
-(def: (text::clip [offsetI lengthI subjectI])
- (Trinary Inst)
- (|>> subjectI ..check_stringI
- offsetI jvm_intI
- _.DUP
- lengthI jvm_intI
- _.IADD
- (_.INVOKEVIRTUAL $String "substring" (type.method [(list) (list type.int type.int) $String (list)]))))
-
-(def: index_method (type.method [(list) (list $String type.int) type.int (list)]))
-(def: (text::index [startI partI textI])
- (Trinary Inst)
- (<| _.with_label (function (_ @not_found))
- _.with_label (function (_ @end))
- (|>> textI ..check_stringI
- partI ..check_stringI
- startI jvm_intI
- (_.INVOKEVIRTUAL $String "indexOf" index_method)
- _.DUP
- (_.int -1)
- (_.IF_ICMPEQ @not_found)
- lux_intI
- runtime.someI
- (_.GOTO @end)
- (_.label @not_found)
- _.POP
- runtime.noneI
- (_.label @end))))
-
-(def: string_method (type.method [(list) (list $String) type.void (list)]))
-(def: (io::log messageI)
- (Unary Inst)
- (let [$PrintStream (type.class "java.io.PrintStream" (list))]
- (|>> (_.GETSTATIC $System "out" $PrintStream)
- messageI
- ..check_stringI
- (_.INVOKEVIRTUAL $PrintStream "println" string_method)
- unitI)))
-
-(def: (io::error messageI)
- (Unary Inst)
- (let [$Error (type.class "java.lang.Error" (list))]
- (|>> (_.NEW $Error)
- _.DUP
- messageI
- ..check_stringI
- (_.INVOKESPECIAL $Error "<init>" string_method)
- _.ATHROW)))
-
-(def: bundle::lux
- Bundle
- (|> (is Bundle bundle.empty)
- (bundle.install "syntax char case!" lux::syntax_char_case!)
- (bundle.install "is" (binary lux::is))
- (bundle.install "try" (unary lux::try))))
-
-(def: bundle::i64
- Bundle
- (<| (bundle.prefix "i64")
- (|> (is Bundle bundle.empty)
- (bundle.install "and" (binary i64::and))
- (bundle.install "or" (binary i64::or))
- (bundle.install "xor" (binary i64::xor))
- (bundle.install "left-shift" (binary i64::left_shift))
- (bundle.install "right-shift" (binary i64::right_shift))
- (bundle.install "=" (binary i64::=))
- (bundle.install "<" (binary i64::<))
- (bundle.install "+" (binary i64::+))
- (bundle.install "-" (binary i64::-))
- (bundle.install "*" (binary i64::*))
- (bundle.install "/" (binary i64::/))
- (bundle.install "%" (binary i64::%))
- (bundle.install "f64" (unary i64::f64))
- (bundle.install "char" (unary i64::char)))))
-
-(def: bundle::f64
- Bundle
- (<| (bundle.prefix "f64")
- (|> (is Bundle bundle.empty)
- (bundle.install "+" (binary f64::+))
- (bundle.install "-" (binary f64::-))
- (bundle.install "*" (binary f64::*))
- (bundle.install "/" (binary f64::/))
- (bundle.install "%" (binary f64::%))
- (bundle.install "=" (binary f64::=))
- (bundle.install "<" (binary f64::<))
- (bundle.install "i64" (unary f64::i64))
- (bundle.install "encode" (unary f64::encode))
- (bundle.install "decode" (unary f64::decode)))))
-
-(def: bundle::text
- Bundle
- (<| (bundle.prefix "text")
- (|> (is Bundle bundle.empty)
- (bundle.install "=" (binary text::=))
- (bundle.install "<" (binary text::<))
- (bundle.install "concat" (binary text::concat))
- (bundle.install "index" (trinary text::index))
- (bundle.install "size" (unary text::size))
- (bundle.install "char" (binary text::char))
- (bundle.install "clip" (trinary text::clip)))))
-
-(def: bundle::io
- Bundle
- (<| (bundle.prefix "io")
- (|> (is Bundle bundle.empty)
- (bundle.install "log" (unary io::log))
- (bundle.install "error" (unary io::error)))))
-
-(def: .public bundle
- Bundle
- (<| (bundle.prefix "lux")
- (|> bundle::lux
- (dictionary.merged bundle::i64)
- (dictionary.merged bundle::f64)
- (dictionary.merged bundle::text)
- (dictionary.merged bundle::io))))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux b/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux
deleted file mode 100644
index cb1ce6f6c..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/extension/host.lux
+++ /dev/null
@@ -1,1248 +0,0 @@
-(.using
- [library
- [lux {"-" Type Label Primitive int char type}
- [ffi {"+" import:}]
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" maybe ("[1]#[0]" functor)]
- ["[0]" exception {"+" exception:}]
- ["[0]" function]
- ["<>" parser ("[1]#[0]" monad)
- ["<[0]>" text]
- ["<[0]>" synthesis {"+" Parser}]]]
- [data
- ["[0]" product]
- ["[0]" text ("[1]#[0]" equivalence)
- ["%" format {"+" format}]]
- [collection
- ["[0]" list ("[1]#[0]" monoid mix monad)]
- ["[0]" dictionary {"+" Dictionary}]
- ["[0]" set {"+" Set}]]]
- [macro
- ["^" pattern]
- ["[0]" template]]
- [math
- [number
- ["n" nat]]]
- [target
- [jvm
- ["[0]" type {"+" Type Typed Argument}
- ["[0]" category {"+" Void Value Return Primitive Object Class Array Var Parameter Method}]
- ["[0]" box]
- ["[0]" reflection]
- ["[0]" signature]
- ["[0]" descriptor]
- ["[0]" parser]]]]
- [tool
- [compiler
- ["[0]" phase ("[1]#[0]" monad)]
- [reference {"+" }
- ["[0]" variable {"+" Variable Register}]]
- [meta
- [archive {"+" Archive}
- ["[0]" unit]]
- ["[0]" cache "_"
- ["[1]" artifact]]]
- [language
- [lux
- [analysis {"+" Environment}]
- ["[0]" synthesis {"+" Synthesis Path %synthesis}]
- ["[0]" generation]
- [phase
- [generation
- [extension {"+" Nullary Unary Binary
- nullary unary binary}]]
- [analysis
- ["[0]A" reference]]
- ["[0]" extension
- ["[0]" bundle]
- [analysis
- ["/" jvm]]]]]]]]]]
- [luxc
- [lang
- [host
- ["$" jvm {"+" Label Inst Def Handler Bundle Operation Phase}
- ["_" inst]
- ["_[0]" def]]]]]
- ["[0]" // "_"
- [common {"+" custom}]
- ["/[1]" //
- ["[1][0]" reference]
- ["[1][0]" function]]])
-
-(template [<name> <category> <parser>]
- [(def: .public <name>
- (Parser (Type <category>))
- (<text>.then <parser> <synthesis>.text))]
-
- [var Var parser.var]
- [class Class parser.class]
- [object Object parser.object]
- [value Value parser.value]
- [return Return parser.return]
- )
-
-(def: signature
- (All (_ a) (-> (Type a) Text))
- (|>> type.signature signature.signature))
-
-(def: descriptor
- (All (_ a) (-> (Type a) Text))
- (|>> type.descriptor descriptor.descriptor))
-
-(exception: .public (not_an_object_array [arrayJT (Type Array)])
- (exception.report
- "JVM Type" (..signature arrayJT)))
-
-(def: .public object_array
- (Parser (Type Object))
- (do <>.monad
- [arrayJT (<text>.then parser.array <synthesis>.text)]
- (case (parser.array? arrayJT)
- {.#Some elementJT}
- (case (parser.object? elementJT)
- {.#Some elementJT}
- (in elementJT)
-
- {.#None}
- (<>.failure (exception.error ..not_an_object_array [arrayJT])))
-
- {.#None}
- (undefined))))
-
-(template [<name> <inst>]
- [(def: <name>
- Inst
- (|>> _.L2I <inst>))]
-
- [L2S _.I2S]
- [L2B _.I2B]
- [L2C _.I2C]
- )
-
-(template [<conversion> <name>]
- [(def: (<name> inputI)
- (Unary Inst)
- (if (same? _.NOP <conversion>)
- inputI
- (|>> inputI
- <conversion>)))]
-
- [_.D2F conversion::double_to_float]
- [_.D2I conversion::double_to_int]
- [_.D2L conversion::double_to_long]
-
- [_.F2D conversion::float_to_double]
- [_.F2I conversion::float_to_int]
- [_.F2L conversion::float_to_long]
-
- [_.I2B conversion::int_to_byte]
- [_.I2C conversion::int_to_char]
- [_.I2D conversion::int_to_double]
- [_.I2F conversion::int_to_float]
- [_.I2L conversion::int_to_long]
- [_.I2S conversion::int_to_short]
-
- [_.L2D conversion::long_to_double]
- [_.L2F conversion::long_to_float]
- [_.L2I conversion::long_to_int]
- [..L2S conversion::long_to_short]
- [..L2B conversion::long_to_byte]
- [..L2C conversion::long_to_char]
-
- [_.I2B conversion::char_to_byte]
- [_.I2S conversion::char_to_short]
- [_.NOP conversion::char_to_int]
- [_.I2L conversion::char_to_long]
-
- [_.I2L conversion::byte_to_long]
-
- [_.I2L conversion::short_to_long]
- )
-
-(def: conversion_bundle
- Bundle
- (<| (bundle.prefix "conversion")
- (|> (is Bundle bundle.empty)
- (bundle.install "double-to-float" (unary conversion::double_to_float))
- (bundle.install "double-to-int" (unary conversion::double_to_int))
- (bundle.install "double-to-long" (unary conversion::double_to_long))
-
- (bundle.install "float-to-double" (unary conversion::float_to_double))
- (bundle.install "float-to-int" (unary conversion::float_to_int))
- (bundle.install "float-to-long" (unary conversion::float_to_long))
-
- (bundle.install "int-to-byte" (unary conversion::int_to_byte))
- (bundle.install "int-to-char" (unary conversion::int_to_char))
- (bundle.install "int-to-double" (unary conversion::int_to_double))
- (bundle.install "int-to-float" (unary conversion::int_to_float))
- (bundle.install "int-to-long" (unary conversion::int_to_long))
- (bundle.install "int-to-short" (unary conversion::int_to_short))
-
- (bundle.install "long-to-double" (unary conversion::long_to_double))
- (bundle.install "long-to-float" (unary conversion::long_to_float))
- (bundle.install "long-to-int" (unary conversion::long_to_int))
- (bundle.install "long-to-short" (unary conversion::long_to_short))
- (bundle.install "long-to-byte" (unary conversion::long_to_byte))
- (bundle.install "long-to-char" (unary conversion::long_to_char))
-
- (bundle.install "char-to-byte" (unary conversion::char_to_byte))
- (bundle.install "char-to-short" (unary conversion::char_to_short))
- (bundle.install "char-to-int" (unary conversion::char_to_int))
- (bundle.install "char-to-long" (unary conversion::char_to_long))
-
- (bundle.install "byte-to-long" (unary conversion::byte_to_long))
-
- (bundle.install "short-to-long" (unary conversion::short_to_long))
- )))
-
-(template [<name> <op>]
- [(def: (<name> [parameterI subjectI])
- (Binary Inst)
- (|>> subjectI
- parameterI
- <op>))]
-
- [int::+ _.IADD]
- [int::- _.ISUB]
- [int::* _.IMUL]
- [int::/ _.IDIV]
- [int::% _.IREM]
- [int::and _.IAND]
- [int::or _.IOR]
- [int::xor _.IXOR]
- [int::shl _.ISHL]
- [int::shr _.ISHR]
- [int::ushr _.IUSHR]
-
- [long::+ _.LADD]
- [long::- _.LSUB]
- [long::* _.LMUL]
- [long::/ _.LDIV]
- [long::% _.LREM]
- [long::and _.LAND]
- [long::or _.LOR]
- [long::xor _.LXOR]
- [long::shl _.LSHL]
- [long::shr _.LSHR]
- [long::ushr _.LUSHR]
-
- [float::+ _.FADD]
- [float::- _.FSUB]
- [float::* _.FMUL]
- [float::/ _.FDIV]
- [float::% _.FREM]
-
- [double::+ _.DADD]
- [double::- _.DSUB]
- [double::* _.DMUL]
- [double::/ _.DDIV]
- [double::% _.DREM]
- )
-
-(def: $Boolean (type.class box.boolean (list)))
-(def: falseI (_.GETSTATIC $Boolean "FALSE" $Boolean))
-(def: trueI (_.GETSTATIC $Boolean "TRUE" $Boolean))
-
-(template [<name> <op>]
- [(def: (<name> [referenceI subjectI])
- (Binary Inst)
- (<| _.with_label (function (_ @then))
- _.with_label (function (_ @end))
- (|>> subjectI
- referenceI
- (<op> @then)
- falseI
- (_.GOTO @end)
- (_.label @then)
- trueI
- (_.label @end))))]
-
- [int::= _.IF_ICMPEQ]
- [int::< _.IF_ICMPLT]
-
- [char::= _.IF_ICMPEQ]
- [char::< _.IF_ICMPLT]
- )
-
-(template [<name> <op> <reference>]
- [(def: (<name> [referenceI subjectI])
- (Binary Inst)
- (<| _.with_label (function (_ @then))
- _.with_label (function (_ @end))
- (|>> subjectI
- referenceI
- <op>
- (_.int <reference>)
- (_.IF_ICMPEQ @then)
- falseI
- (_.GOTO @end)
- (_.label @then)
- trueI
- (_.label @end))))]
-
- [long::= _.LCMP +0]
- [long::< _.LCMP -1]
-
- [float::= _.FCMPG +0]
- [float::< _.FCMPG -1]
-
- [double::= _.DCMPG +0]
- [double::< _.DCMPG -1]
- )
-
-(def: int_bundle
- Bundle
- (<| (bundle.prefix (reflection.reflection reflection.int))
- (|> (is Bundle bundle.empty)
- (bundle.install "+" (binary int::+))
- (bundle.install "-" (binary int::-))
- (bundle.install "*" (binary int::*))
- (bundle.install "/" (binary int::/))
- (bundle.install "%" (binary int::%))
- (bundle.install "=" (binary int::=))
- (bundle.install "<" (binary int::<))
- (bundle.install "and" (binary int::and))
- (bundle.install "or" (binary int::or))
- (bundle.install "xor" (binary int::xor))
- (bundle.install "shl" (binary int::shl))
- (bundle.install "shr" (binary int::shr))
- (bundle.install "ushr" (binary int::ushr))
- )))
-
-(def: long_bundle
- Bundle
- (<| (bundle.prefix (reflection.reflection reflection.long))
- (|> (is Bundle bundle.empty)
- (bundle.install "+" (binary long::+))
- (bundle.install "-" (binary long::-))
- (bundle.install "*" (binary long::*))
- (bundle.install "/" (binary long::/))
- (bundle.install "%" (binary long::%))
- (bundle.install "=" (binary long::=))
- (bundle.install "<" (binary long::<))
- (bundle.install "and" (binary long::and))
- (bundle.install "or" (binary long::or))
- (bundle.install "xor" (binary long::xor))
- (bundle.install "shl" (binary long::shl))
- (bundle.install "shr" (binary long::shr))
- (bundle.install "ushr" (binary long::ushr))
- )))
-
-(def: float_bundle
- Bundle
- (<| (bundle.prefix (reflection.reflection reflection.float))
- (|> (is Bundle bundle.empty)
- (bundle.install "+" (binary float::+))
- (bundle.install "-" (binary float::-))
- (bundle.install "*" (binary float::*))
- (bundle.install "/" (binary float::/))
- (bundle.install "%" (binary float::%))
- (bundle.install "=" (binary float::=))
- (bundle.install "<" (binary float::<))
- )))
-
-(def: double_bundle
- Bundle
- (<| (bundle.prefix (reflection.reflection reflection.double))
- (|> (is Bundle bundle.empty)
- (bundle.install "+" (binary double::+))
- (bundle.install "-" (binary double::-))
- (bundle.install "*" (binary double::*))
- (bundle.install "/" (binary double::/))
- (bundle.install "%" (binary double::%))
- (bundle.install "=" (binary double::=))
- (bundle.install "<" (binary double::<))
- )))
-
-(def: char_bundle
- Bundle
- (<| (bundle.prefix (reflection.reflection reflection.char))
- (|> (is Bundle bundle.empty)
- (bundle.install "=" (binary char::=))
- (bundle.install "<" (binary char::<))
- )))
-
-(def: (primitive_array_length_handler jvm_primitive)
- (-> (Type Primitive) Handler)
- (..custom
- [<synthesis>.any
- (function (_ extension_name generate archive arrayS)
- (do phase.monad
- [arrayI (generate archive arrayS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array jvm_primitive))
- _.ARRAYLENGTH))))]))
-
-(def: array::length::object
- Handler
- (..custom
- [($_ <>.and ..object_array <synthesis>.any)
- (function (_ extension_name generate archive [elementJT arrayS])
- (do phase.monad
- [arrayI (generate archive arrayS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array elementJT))
- _.ARRAYLENGTH))))]))
-
-(def: (new_primitive_array_handler jvm_primitive)
- (-> (Type Primitive) Handler)
- (function (_ extension_name generate archive inputs)
- (case inputs
- (pattern (list lengthS))
- (do phase.monad
- [lengthI (generate archive lengthS)]
- (in (|>> lengthI
- (_.array jvm_primitive))))
-
- _
- (phase.except extension.invalid_syntax [extension_name %synthesis inputs]))))
-
-(def: array::new::object
- Handler
- (..custom
- [($_ <>.and ..object <synthesis>.any)
- (function (_ extension_name generate archive [objectJT lengthS])
- (do phase.monad
- [lengthI (generate archive lengthS)]
- (in (|>> lengthI
- (_.ANEWARRAY objectJT)))))]))
-
-(def: (read_primitive_array_handler jvm_primitive loadI)
- (-> (Type Primitive) Inst Handler)
- (function (_ extension_name generate archive inputs)
- (case inputs
- (pattern (list idxS arrayS))
- (do phase.monad
- [arrayI (generate archive arrayS)
- idxI (generate archive idxS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array jvm_primitive))
- idxI
- loadI)))
-
- _
- (phase.except extension.invalid_syntax [extension_name %synthesis inputs]))))
-
-(def: array::read::object
- Handler
- (..custom
- [($_ <>.and ..object_array <synthesis>.any <synthesis>.any)
- (function (_ extension_name generate archive [elementJT idxS arrayS])
- (do phase.monad
- [arrayI (generate archive arrayS)
- idxI (generate archive idxS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array elementJT))
- idxI
- _.AALOAD))))]))
-
-(def: (write_primitive_array_handler jvm_primitive storeI)
- (-> (Type Primitive) Inst Handler)
- (function (_ extension_name generate archive inputs)
- (case inputs
- (pattern (list idxS valueS arrayS))
- (do phase.monad
- [arrayI (generate archive arrayS)
- idxI (generate archive idxS)
- valueI (generate archive valueS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array jvm_primitive))
- _.DUP
- idxI
- valueI
- storeI)))
-
- _
- (phase.except extension.invalid_syntax [extension_name %synthesis inputs]))))
-
-(def: array::write::object
- Handler
- (..custom
- [($_ <>.and ..object_array <synthesis>.any <synthesis>.any <synthesis>.any)
- (function (_ extension_name generate archive [elementJT idxS valueS arrayS])
- (do phase.monad
- [arrayI (generate archive arrayS)
- idxI (generate archive idxS)
- valueI (generate archive valueS)]
- (in (|>> arrayI
- (_.CHECKCAST (type.array elementJT))
- _.DUP
- idxI
- valueI
- _.AASTORE))))]))
-
-(def: array_bundle
- Bundle
- (<| (bundle.prefix "array")
- (|> bundle.empty
- (dictionary.merged (<| (bundle.prefix "length")
- (|> bundle.empty
- (bundle.install (reflection.reflection reflection.boolean) (primitive_array_length_handler type.boolean))
- (bundle.install (reflection.reflection reflection.byte) (primitive_array_length_handler type.byte))
- (bundle.install (reflection.reflection reflection.short) (primitive_array_length_handler type.short))
- (bundle.install (reflection.reflection reflection.int) (primitive_array_length_handler type.int))
- (bundle.install (reflection.reflection reflection.long) (primitive_array_length_handler type.long))
- (bundle.install (reflection.reflection reflection.float) (primitive_array_length_handler type.float))
- (bundle.install (reflection.reflection reflection.double) (primitive_array_length_handler type.double))
- (bundle.install (reflection.reflection reflection.char) (primitive_array_length_handler type.char))
- (bundle.install "object" array::length::object))))
- (dictionary.merged (<| (bundle.prefix "new")
- (|> bundle.empty
- (bundle.install (reflection.reflection reflection.boolean) (new_primitive_array_handler type.boolean))
- (bundle.install (reflection.reflection reflection.byte) (new_primitive_array_handler type.byte))
- (bundle.install (reflection.reflection reflection.short) (new_primitive_array_handler type.short))
- (bundle.install (reflection.reflection reflection.int) (new_primitive_array_handler type.int))
- (bundle.install (reflection.reflection reflection.long) (new_primitive_array_handler type.long))
- (bundle.install (reflection.reflection reflection.float) (new_primitive_array_handler type.float))
- (bundle.install (reflection.reflection reflection.double) (new_primitive_array_handler type.double))
- (bundle.install (reflection.reflection reflection.char) (new_primitive_array_handler type.char))
- (bundle.install "object" array::new::object))))
- (dictionary.merged (<| (bundle.prefix "read")
- (|> bundle.empty
- (bundle.install (reflection.reflection reflection.boolean) (read_primitive_array_handler type.boolean _.BALOAD))
- (bundle.install (reflection.reflection reflection.byte) (read_primitive_array_handler type.byte _.BALOAD))
- (bundle.install (reflection.reflection reflection.short) (read_primitive_array_handler type.short _.SALOAD))
- (bundle.install (reflection.reflection reflection.int) (read_primitive_array_handler type.int _.IALOAD))
- (bundle.install (reflection.reflection reflection.long) (read_primitive_array_handler type.long _.LALOAD))
- (bundle.install (reflection.reflection reflection.float) (read_primitive_array_handler type.float _.FALOAD))
- (bundle.install (reflection.reflection reflection.double) (read_primitive_array_handler type.double _.DALOAD))
- (bundle.install (reflection.reflection reflection.char) (read_primitive_array_handler type.char _.CALOAD))
- (bundle.install "object" array::read::object))))
- (dictionary.merged (<| (bundle.prefix "write")
- (|> bundle.empty
- (bundle.install (reflection.reflection reflection.boolean) (write_primitive_array_handler type.boolean _.BASTORE))
- (bundle.install (reflection.reflection reflection.byte) (write_primitive_array_handler type.byte _.BASTORE))
- (bundle.install (reflection.reflection reflection.short) (write_primitive_array_handler type.short _.SASTORE))
- (bundle.install (reflection.reflection reflection.int) (write_primitive_array_handler type.int _.IASTORE))
- (bundle.install (reflection.reflection reflection.long) (write_primitive_array_handler type.long _.LASTORE))
- (bundle.install (reflection.reflection reflection.float) (write_primitive_array_handler type.float _.FASTORE))
- (bundle.install (reflection.reflection reflection.double) (write_primitive_array_handler type.double _.DASTORE))
- (bundle.install (reflection.reflection reflection.char) (write_primitive_array_handler type.char _.CASTORE))
- (bundle.install "object" array::write::object))))
- )))
-
-(def: (object::null _)
- (Nullary Inst)
- _.NULL)
-
-(def: (object::null? objectI)
- (Unary Inst)
- (<| _.with_label (function (_ @then))
- _.with_label (function (_ @end))
- (|>> objectI
- (_.IFNULL @then)
- falseI
- (_.GOTO @end)
- (_.label @then)
- trueI
- (_.label @end))))
-
-(def: (object::synchronized [monitorI exprI])
- (Binary Inst)
- (|>> monitorI
- _.DUP
- _.MONITORENTER
- exprI
- _.SWAP
- _.MONITOREXIT))
-
-(def: (object::throw exceptionI)
- (Unary Inst)
- (|>> exceptionI
- _.ATHROW))
-
-(def: $Class
- (type.class "java.lang.Class" (list)))
-
-(def: (object::class extension_name generate archive inputs)
- Handler
- (case inputs
- (pattern (list (synthesis.text class)))
- (do phase.monad
- []
- (in (|>> (_.string class)
- (_.INVOKESTATIC $Class "forName" (type.method [(list) (list (type.class "java.lang.String" (list))) $Class (list)])))))
-
- _
- (phase.except extension.invalid_syntax [extension_name %synthesis inputs])))
-
-(def: object::instance?
- Handler
- (..custom
- [($_ <>.and <synthesis>.text <synthesis>.any)
- (function (_ extension_name generate archive [class objectS])
- (do phase.monad
- [objectI (generate archive objectS)]
- (in (|>> objectI
- (_.INSTANCEOF (type.class class (list)))
- (_.wrap type.boolean)))))]))
-
-(def: (object::cast extension_name generate archive inputs)
- Handler
- (case inputs
- (pattern (list (synthesis.text from) (synthesis.text to) valueS))
- (do phase.monad
- [valueI (generate archive valueS)]
- (`` (cond (~~ (template [<object> <primitive>]
- [(and (text#= (reflection.reflection (type.reflection <primitive>))
- from)
- (text#= <object>
- to))
- (in (|>> valueI (_.wrap <primitive>)))
-
- (and (text#= <object>
- from)
- (text#= (reflection.reflection (type.reflection <primitive>))
- to))
- (in (|>> valueI (_.unwrap <primitive>)))]
-
- [box.boolean type.boolean]
- [box.byte type.byte]
- [box.short type.short]
- [box.int type.int]
- [box.long type.long]
- [box.float type.float]
- [box.double type.double]
- [box.char type.char]))
- ... else
- (in valueI))))
-
- _
- (phase.except extension.invalid_syntax [extension_name %synthesis inputs])))
-
-(def: object_bundle
- Bundle
- (<| (bundle.prefix "object")
- (|> (is Bundle bundle.empty)
- (bundle.install "null" (nullary object::null))
- (bundle.install "null?" (unary object::null?))
- (bundle.install "synchronized" (binary object::synchronized))
- (bundle.install "throw" (unary object::throw))
- (bundle.install "class" object::class)
- (bundle.install "instance?" object::instance?)
- (bundle.install "cast" object::cast)
- )))
-
-(def: primitives
- (Dictionary Text (Type Primitive))
- (|> (list [(reflection.reflection reflection.boolean) type.boolean]
- [(reflection.reflection reflection.byte) type.byte]
- [(reflection.reflection reflection.short) type.short]
- [(reflection.reflection reflection.int) type.int]
- [(reflection.reflection reflection.long) type.long]
- [(reflection.reflection reflection.float) type.float]
- [(reflection.reflection reflection.double) type.double]
- [(reflection.reflection reflection.char) type.char])
- (dictionary.of_list text.hash)))
-
-(def: get::static
- Handler
- (..custom
- [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text)
- (function (_ extension_name generate archive [class field unboxed])
- (do phase.monad
- []
- (case (dictionary.value unboxed ..primitives)
- {.#Some primitive}
- (in (_.GETSTATIC (type.class class (list)) field primitive))
-
- {.#None}
- (in (_.GETSTATIC (type.class class (list)) field (type.class unboxed (list)))))))]))
-
-(def: put::static
- Handler
- (..custom
- [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any)
- (function (_ extension_name generate archive [class field unboxed valueS])
- (do phase.monad
- [valueI (generate archive valueS)
- .let [$class (type.class class (list))]]
- (case (dictionary.value unboxed ..primitives)
- {.#Some primitive}
- (in (|>> valueI
- (_.PUTSTATIC $class field primitive)
- (_.string synthesis.unit)))
-
- {.#None}
- (in (|>> valueI
- (_.CHECKCAST $class)
- (_.PUTSTATIC $class field $class)
- (_.string synthesis.unit))))))]))
-
-(def: get::virtual
- Handler
- (..custom
- [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any)
- (function (_ extension_name generate archive [class field unboxed objectS])
- (do phase.monad
- [objectI (generate archive objectS)
- .let [$class (type.class class (list))
- getI (case (dictionary.value unboxed ..primitives)
- {.#Some primitive}
- (_.GETFIELD $class field primitive)
-
- {.#None}
- (_.GETFIELD $class field (type.class unboxed (list))))]]
- (in (|>> objectI
- (_.CHECKCAST $class)
- getI))))]))
-
-(def: put::virtual
- Handler
- (..custom
- [($_ <>.and <synthesis>.text <synthesis>.text <synthesis>.text <synthesis>.any <synthesis>.any)
- (function (_ extension_name generate archive [class field unboxed valueS objectS])
- (do phase.monad
- [valueI (generate archive valueS)
- objectI (generate archive objectS)
- .let [$class (type.class class (list))
- putI (case (dictionary.value unboxed ..primitives)
- {.#Some primitive}
- (_.PUTFIELD $class field primitive)
-
- {.#None}
- (let [$unboxed (type.class unboxed (list))]
- (|>> (_.CHECKCAST $unboxed)
- (_.PUTFIELD $class field $unboxed))))]]
- (in (|>> objectI
- (_.CHECKCAST $class)
- _.DUP
- valueI
- putI))))]))
-
-(type: Input
- (Typed Synthesis))
-
-(def: input
- (Parser Input)
- (<synthesis>.tuple (<>.and ..value <synthesis>.any)))
-
-(def: (generate_input generate archive [valueT valueS])
- (-> Phase Archive Input
- (Operation (Typed Inst)))
- (do phase.monad
- [valueI (generate archive valueS)]
- (case (type.primitive? valueT)
- {.#Right valueT}
- (in [valueT valueI])
-
- {.#Left valueT}
- (in [valueT (|>> valueI
- (_.CHECKCAST valueT))]))))
-
-(def: voidI
- (_.string synthesis.unit))
-
-(def: (prepare_output outputT)
- (-> (Type Return) Inst)
- (case (type.void? outputT)
- {.#Right outputT}
- ..voidI
-
- {.#Left outputT}
- function.identity))
-
-(def: invoke::static
- Handler
- (..custom
- [($_ <>.and ..class <synthesis>.text ..return (<>.some ..input))
- (function (_ extension_name generate archive [class method outputT inputsTS])
- (do [! phase.monad]
- [inputsTI (monad.each ! (generate_input generate archive) inputsTS)]
- (in (|>> (_.fuse (list#each product.right inputsTI))
- (_.INVOKESTATIC class method (type.method [(list) (list#each product.left inputsTI) outputT (list)]))
- (prepare_output outputT)))))]))
-
-(template [<name> <invoke>]
- [(def: <name>
- Handler
- (..custom
- [($_ <>.and ..class <synthesis>.text ..return <synthesis>.any (<>.some ..input))
- (function (_ extension_name generate archive [class method outputT objectS inputsTS])
- (do [! phase.monad]
- [objectI (generate archive objectS)
- inputsTI (monad.each ! (generate_input generate archive) inputsTS)]
- (in (|>> objectI
- (_.CHECKCAST class)
- (_.fuse (list#each product.right inputsTI))
- (<invoke> class method
- (type.method [(list)
- (list#each product.left inputsTI)
- outputT
- (list)]))
- (prepare_output outputT)))))]))]
-
- [invoke::virtual _.INVOKEVIRTUAL]
- [invoke::special _.INVOKESPECIAL]
- [invoke::interface _.INVOKEINTERFACE]
- )
-
-(def: invoke::constructor
- Handler
- (..custom
- [($_ <>.and ..class (<>.some ..input))
- (function (_ extension_name generate archive [class inputsTS])
- (do [! phase.monad]
- [inputsTI (monad.each ! (generate_input generate archive) inputsTS)]
- (in (|>> (_.NEW class)
- _.DUP
- (_.fuse (list#each product.right inputsTI))
- (_.INVOKESPECIAL class "<init>" (type.method [(list) (list#each product.left inputsTI) type.void (list)]))))))]))
-
-(def: member_bundle
- Bundle
- (<| (bundle.prefix "member")
- (|> (is Bundle bundle.empty)
- (dictionary.merged (<| (bundle.prefix "get")
- (|> (is Bundle bundle.empty)
- (bundle.install "static" get::static)
- (bundle.install "virtual" get::virtual))))
- (dictionary.merged (<| (bundle.prefix "put")
- (|> (is Bundle bundle.empty)
- (bundle.install "static" put::static)
- (bundle.install "virtual" put::virtual))))
- (dictionary.merged (<| (bundle.prefix "invoke")
- (|> (is Bundle bundle.empty)
- (bundle.install "static" invoke::static)
- (bundle.install "virtual" invoke::virtual)
- (bundle.install "special" invoke::special)
- (bundle.install "interface" invoke::interface)
- (bundle.install "constructor" invoke::constructor))))
- )))
-
-(def: annotation_parameter
- (Parser (/.Annotation_Parameter Synthesis))
- (<synthesis>.tuple (<>.and <synthesis>.text <synthesis>.any)))
-
-(def: annotation
- (Parser (/.Annotation Synthesis))
- (<synthesis>.tuple (<>.and <synthesis>.text (<>.some ..annotation_parameter))))
-
-(def: argument
- (Parser Argument)
- (<synthesis>.tuple (<>.and <synthesis>.text ..value)))
-
-(def: .public (hidden_method_body arity body)
- (-> Nat Synthesis Synthesis)
- (case [arity body]
- [0 _] body
- [1 _] body
-
- [2 {synthesis.#Control {synthesis.#Branch {synthesis.#Let _ 2 hidden}}}]
- hidden
-
- [_ {synthesis.#Control {synthesis.#Branch {synthesis.#Case _ path}}}]
- (loop (again [path (is synthesis.Path path)])
- (case path
- (^.or {synthesis.#Pop}
- {synthesis.#Access _}
- {synthesis.#Bind _}
- {synthesis.#Bit_Fork _}
- {synthesis.#I64_Fork _}
- {synthesis.#F64_Fork _}
- {synthesis.#Text_Fork _}
- {synthesis.#Alt _})
- body
-
- {synthesis.#Seq _ next}
- (again next)
-
- {synthesis.#Then hidden}
- hidden))
-
- _
- body))
-
-(def: overriden_method_definition
- (Parser [(Environment Synthesis) (/.Overriden_Method Synthesis)])
- (<synthesis>.tuple
- (do <>.monad
- [_ (<synthesis>.this_text /.overriden_tag)
- ownerT ..class
- name <synthesis>.text
- strict_fp? <synthesis>.bit
- annotations (<synthesis>.tuple (<>.some ..annotation))
- vars (<synthesis>.tuple (<>.some ..var))
- self_name <synthesis>.text
- arguments (<synthesis>.tuple (<>.some ..argument))
- returnT ..return
- exceptionsT (<synthesis>.tuple (<>.some ..class))
- [environment _ _ body] (<| (<synthesis>.function 1)
- (<synthesis>.loop (<>.exactly 0 <synthesis>.any))
- <synthesis>.tuple
- (<>.after <synthesis>.any)
- <synthesis>.any)]
- (in [environment
- [ownerT name
- strict_fp? annotations vars
- self_name arguments returnT exceptionsT
- (..hidden_method_body (list.size arguments) body)]]))))
-
-(def: (normalize_path normalize)
- (-> (-> Synthesis Synthesis)
- (-> Path Path))
- (function (again path)
- (case path
- (pattern (synthesis.path/then bodyS))
- (synthesis.path/then (normalize bodyS))
-
- (^.template [<tag>]
- [(pattern {<tag> leftP rightP})
- {<tag> (again leftP) (again rightP)}])
- ([synthesis.#Alt]
- [synthesis.#Seq])
-
- (^.template [<tag>]
- [(pattern {<tag> _})
- path])
- ([synthesis.#Pop]
- [synthesis.#Bind]
- [synthesis.#Access])
-
- {synthesis.#Bit_Fork when then else}
- {synthesis.#Bit_Fork when (again then) (maybe#each again else)}
-
- (^.template [<tag>]
- [{<tag> [[test then] elses]}
- {<tag> [[test (again then)]
- (list#each (function (_ [else_test else_then])
- [else_test (again else_then)])
- elses)]}])
- ([synthesis.#I64_Fork]
- [synthesis.#F64_Fork]
- [synthesis.#Text_Fork])
- )))
-
-(type: Mapping
- (Dictionary Synthesis Variable))
-
-(def: (local_mapping global_mapping)
- (-> Mapping (Environment Synthesis) Mapping)
- (|>> list.enumeration
- (list#each (function (_ [foreign_id capture])
- [(synthesis.variable/foreign foreign_id)
- (|> global_mapping
- (dictionary.value capture)
- maybe.trusted)]))
- (dictionary.of_list synthesis.hash)))
-
-(def: (init_mapping global_mapping)
- (-> Mapping (Environment Synthesis) Mapping)
- (|>> list.enumeration
- (list#each (function (_ [id capture])
- [(synthesis.variable/foreign id)
- {variable.#Local (++ id)}]))
- (dictionary.of_list synthesis.hash)))
-
-(def: (normalize_method_body mapping)
- (-> Mapping Synthesis Synthesis)
- (function (again body)
- (case body
- (^.template [<tag>]
- [(pattern <tag>)
- body])
- ([{synthesis.#Primitive _}]
- [(synthesis.constant _)])
-
- (pattern (synthesis.variant [lefts right? sub]))
- (synthesis.variant [lefts right? (again sub)])
-
- (pattern (synthesis.tuple members))
- (synthesis.tuple (list#each again members))
-
- (pattern (synthesis.variable var))
- (|> mapping
- (dictionary.value body)
- (maybe.else var)
- synthesis.variable)
-
- (pattern (synthesis.branch/case [inputS pathS]))
- (synthesis.branch/case [(again inputS) (normalize_path again pathS)])
-
- (pattern (synthesis.branch/exec [this that]))
- (synthesis.branch/exec [(again this) (again that)])
-
- (pattern (synthesis.branch/let [inputS register outputS]))
- (synthesis.branch/let [(again inputS) register (again outputS)])
-
- (pattern (synthesis.branch/if [testS thenS elseS]))
- (synthesis.branch/if [(again testS) (again thenS) (again elseS)])
-
- (pattern (synthesis.branch/get [path recordS]))
- (synthesis.branch/get [path (again recordS)])
-
- (pattern (synthesis.loop/scope [offset initsS+ bodyS]))
- (synthesis.loop/scope [offset (list#each again initsS+) (again bodyS)])
-
- (pattern (synthesis.loop/again updatesS+))
- (synthesis.loop/again (list#each again updatesS+))
-
- (pattern (synthesis.function/abstraction [environment arity bodyS]))
- (synthesis.function/abstraction [(list#each (function (_ captured)
- (case captured
- (pattern (synthesis.variable var))
- (|> mapping
- (dictionary.value captured)
- (maybe.else var)
- synthesis.variable)
-
- _
- captured))
- environment)
- arity
- bodyS])
-
- (pattern (synthesis.function/apply [functionS inputsS+]))
- (synthesis.function/apply [(again functionS) (list#each again inputsS+)])
-
- {synthesis.#Extension [name inputsS+]}
- {synthesis.#Extension [name (list#each again inputsS+)]})))
-
-(def: $Object
- (type.class "java.lang.Object" (list)))
-
-(def: (anonymous_init_method env inputsTI)
- (-> (Environment Synthesis) (List (Typed Inst)) (Type Method))
- (type.method [(list)
- (list.repeated (n.+ (list.size inputsTI) (list.size env)) $Object)
- type.void
- (list)]))
-
-(def: (with_anonymous_init class env super_class inputsTI)
- (-> (Type Class) (Environment Synthesis) (Type Class) (List (Typed Inst)) Def)
- (let [inputs_offset (list.size inputsTI)
- inputs! (|> inputsTI
- list.enumeration
- (list#each (function (_ [register [type term]])
- (let [then! (case (type.primitive? type)
- {.#Right type}
- (_.unwrap type)
-
- {.#Left type}
- (_.CHECKCAST type))]
- (|>> (_.ALOAD (++ register))
- then!))))
- _.fuse)
- store_capturedI (|> env
- list.size
- list.indices
- (list#each (.function (_ register)
- (|>> (_.ALOAD 0)
- (_.ALOAD (n.+ inputs_offset (++ register)))
- (_.PUTFIELD class (///reference.foreign_name register) $Object))))
- _.fuse)]
- (_def.method {$.#Public} $.noneM "<init>" (anonymous_init_method env inputsTI)
- (|>> (_.ALOAD 0)
- inputs!
- (_.INVOKESPECIAL super_class "<init>" (type.method [(list) (list#each product.left inputsTI) type.void (list)]))
- store_capturedI
- _.RETURN))))
-
-(def: (anonymous_instance generate archive class env inputsTI)
- (-> Phase Archive (Type Class) (Environment Synthesis) (List (Typed Inst)) (Operation Inst))
- (do [! phase.monad]
- [captureI+ (monad.each ! (generate archive) env)]
- (in (|>> (_.NEW class)
- _.DUP
- ((_.fuse (list#each product.right inputsTI)))
- ((_.fuse captureI+))
- (_.INVOKESPECIAL class "<init>" (anonymous_init_method env inputsTI))))))
-
-(def: (prepare_argument lux_register argumentT jvm_register)
- (-> Register (Type Value) Register [Register Inst])
- (case (type.primitive? argumentT)
- {.#Left argumentT}
- [(n.+ 1 jvm_register)
- (if (n.= lux_register jvm_register)
- (|>>)
- (|>> (_.ALOAD jvm_register)
- (_.ASTORE lux_register)))]
-
- {.#Right argumentT}
- (template.let [(wrap_primitive <shift> <load> <type>)
- [[(n.+ <shift> jvm_register)
- (|>> (<load> jvm_register)
- (_.wrap <type>)
- (_.ASTORE lux_register))]]]
- (`` (cond (~~ (template [<shift> <load> <type>]
- [(# type.equivalence = <type> argumentT)
- (wrap_primitive <shift> <load> <type>)]
-
- [1 _.ILOAD type.boolean]
- [1 _.ILOAD type.byte]
- [1 _.ILOAD type.short]
- [1 _.ILOAD type.int]
- [1 _.ILOAD type.char]
- [1 _.FLOAD type.float]
- [2 _.LLOAD type.long]))
-
- ... (# type.equivalence = type.double argumentT)
- (wrap_primitive 2 _.DLOAD type.double))))))
-
-(def: .public (prepare_arguments offset types)
- (-> Nat (List (Type Value)) Inst)
- (|> types
- list.enumeration
- (list#mix (function (_ [lux_register type] [jvm_register before])
- (let [[jvm_register' after] (prepare_argument (n.+ offset lux_register) type jvm_register)]
- [jvm_register' (|>> before after)]))
- (is [Register Inst] [offset (|>>)]))
- product.right))
-
-(def: .public (returnI returnT)
- (-> (Type Return) Inst)
- (case (type.void? returnT)
- {.#Right returnT}
- _.RETURN
-
- {.#Left returnT}
- (case (type.primitive? returnT)
- {.#Left returnT}
- (case (type.class? returnT)
- {.#Some class_name}
- (|>> (_.CHECKCAST returnT)
- _.ARETURN)
-
- {.#None}
- _.ARETURN)
-
- {.#Right returnT}
- (template.let [(unwrap_primitive <return> <type>)
- [(|>> (_.unwrap <type>)
- <return>)]]
- (`` (cond (~~ (template [<return> <type>]
- [(# type.equivalence = <type> returnT)
- (unwrap_primitive <return> <type>)]
-
- [_.IRETURN type.boolean]
- [_.IRETURN type.byte]
- [_.IRETURN type.short]
- [_.IRETURN type.int]
- [_.IRETURN type.char]
- [_.FRETURN type.float]
- [_.LRETURN type.long]))
-
- ... (# type.equivalence = type.double returnT)
- (unwrap_primitive _.DRETURN type.double)))))))
-
-(def: (method_dependencies archive method)
- (-> Archive (/.Overriden_Method Synthesis) (Operation (Set unit.ID)))
- (let [[_super _name _strict_fp? _annotations
- _t_vars _this _arguments _return _exceptions
- bodyS] method]
- (cache.dependencies archive bodyS)))
-
-(def: class::anonymous
- Handler
- (..custom
- [($_ <>.and
- ..class
- (<synthesis>.tuple (<>.some ..class))
- (<synthesis>.tuple (<>.some ..input))
- (<synthesis>.tuple (<>.some ..overriden_method_definition)))
- (function (_ extension_name generate archive [super_class
- super_interfaces
- inputsTS
- overriden_methods])
- (do [! phase.monad]
- [all_input_dependencies (monad.each ! (|>> product.right (cache.dependencies archive)) inputsTS)
- all_closure_dependencies (|> overriden_methods
- (list#each product.left)
- list.together
- (monad.each ! (cache.dependencies archive)))
- all_method_dependencies (monad.each ! (|>> product.right (method_dependencies archive)) overriden_methods)
- .let [all_dependencies (cache.all ($_ list#composite
- all_input_dependencies
- all_closure_dependencies
- all_method_dependencies))]
- [context _] (generation.with_new_context
- archive
- all_dependencies
- (in []))
- .let [[module_id artifact_id] context
- anonymous_class_name (///.class_name context)
- class (type.class anonymous_class_name (list))
- total_environment (|> overriden_methods
- ... Get all the environments.
- (list#each product.left)
- ... Combine them.
- list#conjoint
- ... Remove duplicates.
- (set.of_list synthesis.hash)
- set.list)
- global_mapping (|> total_environment
- ... Give them names as "foreign" variables.
- list.enumeration
- (list#each (function (_ [id capture])
- [capture {variable.#Foreign id}]))
- (dictionary.of_list synthesis.hash))
- normalized_methods (list#each (function (_ [environment
- [ownerT name
- strict_fp? annotations vars
- self_name arguments returnT exceptionsT
- body]])
- [ownerT name
- strict_fp? annotations vars
- self_name arguments returnT exceptionsT
- (normalize_method_body (..local_mapping global_mapping environment)
- body)])
- overriden_methods)
- inputsTS (let [mapping (..init_mapping global_mapping total_environment)]
- (list#each (function (_ [type term])
- [type (normalize_method_body mapping term)])
- inputsTS))]
- inputsTI (generation.with_context artifact_id
- (monad.each ! (generate_input generate archive) inputsTS))
- method_definitions (|> normalized_methods
- (monad.each ! (function (_ [ownerT name
- strict_fp? annotations varsT
- self_name arguments returnT exceptionsT
- bodyS])
- (do !
- [bodyG (generation.with_context artifact_id
- (generate archive bodyS))
- .let [argumentsT (list#each product.right arguments)]]
- (in (_def.method {$.#Public}
- (if strict_fp?
- ($_ $.++M $.finalM $.strictM)
- $.finalM)
- name
- (type.method [varsT argumentsT returnT exceptionsT])
- (|>> (prepare_arguments 1 argumentsT)
- bodyG
- (returnI returnT)))))))
- (# ! each _def.fuse))
- .let [directive [anonymous_class_name
- (_def.class {$.#V1_6} {$.#Public} $.finalC
- anonymous_class_name (list)
- super_class super_interfaces
- (|>> (///function.with_environment total_environment)
- (..with_anonymous_init class total_environment super_class inputsTI)
- method_definitions))]]
- _ (generation.execute! directive)
- _ (generation.save! artifact_id {.#None} directive)]
- (..anonymous_instance generate archive class total_environment inputsTI)))]))
-
-(def: class_bundle
- Bundle
- (<| (bundle.prefix "class")
- (|> (is Bundle bundle.empty)
- (bundle.install "anonymous" class::anonymous)
- )))
-
-(def: .public bundle
- Bundle
- (<| (bundle.prefix "jvm")
- (|> ..conversion_bundle
- (dictionary.merged ..int_bundle)
- (dictionary.merged ..long_bundle)
- (dictionary.merged ..float_bundle)
- (dictionary.merged ..double_bundle)
- (dictionary.merged ..char_bundle)
- (dictionary.merged ..array_bundle)
- (dictionary.merged ..object_bundle)
- (dictionary.merged ..member_bundle)
- (dictionary.merged ..class_bundle)
- )))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/function.lux b/lux-jvm/source/luxc/lang/translation/jvm/function.lux
deleted file mode 100644
index 49147b68b..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/function.lux
+++ /dev/null
@@ -1,359 +0,0 @@
-(.using
- [library
- [lux {"-" Type Label Primitive function}
- [abstract
- ["[0]" monad {"+" do}]
- ["[0]" enum]]
- [control
- ["[0]" pipe]
- ["[0]" function]]
- [data
- ["[0]" product]
- [text
- ["%" format {"+" format}]]
- [collection
- ["[0]" list ("[1]@[0]" functor monoid)]]]
- [math
- [number
- ["n" nat]
- ["i" int]]]
- [target
- [jvm
- ["[0]" type {"+" Type}
- ["[0]" category {"+" Void Value Return Primitive Object Class Array Var Parameter Method}]]]]
- [tool
- [compiler
- [arity {"+" Arity}]
- ["[0]" phase]
- [reference
- [variable {"+" Register}]]
- [language
- [lux
- [analysis {"+" Environment}]
- [synthesis {"+" Synthesis Abstraction Apply}]
- ["[0]" generation]]]
- [meta
- [archive {"+" Archive}
- ["[0]" unit]]
- ["[0]" cache "_"
- ["[1]" artifact]]]]]]]
- [luxc
- [lang
- [host
- ["$" jvm {"+" Label Inst Def Operation Phase Generator}
- ["[0]" def]
- ["_" inst]]]]]
- ["[0]" //
- ["[1][0]" runtime]
- ["[0]" reference]])
-
-(def: arity_field Text "arity")
-
-(def: poly_arg?
- (-> Arity Bit)
- (n.> 1))
-
-(def: (captured_args env)
- (-> (Environment Synthesis) (List (Type Value)))
- (list.repeated (list.size env) //.$Value))
-
-(def: (init_method env arity)
- (-> (Environment Synthesis) Arity (Type Method))
- (if (poly_arg? arity)
- (type.method [(list)
- (list.together (list (captured_args env)
- (list type.int)
- (list.repeated (-- arity) //.$Value)))
- type.void
- (list)])
- (type.method [(list) (captured_args env) type.void (list)])))
-
-(def: (implementation_method arity)
- (type.method [(list) (list.repeated arity //.$Value) //.$Value (list)]))
-
-(def: get_amount_of_partialsI
- Inst
- (|>> (_.ALOAD 0)
- (_.GETFIELD //.$Function //runtime.partials_field type.int)))
-
-(def: (load_fieldI class field)
- (-> (Type Class) Text Inst)
- (|>> (_.ALOAD 0)
- (_.GETFIELD class field //.$Value)))
-
-(def: (inputsI start amount)
- (-> Register Nat Inst)
- (|> (enum.range n.enum start (n.+ start (-- amount)))
- (list@each _.ALOAD)
- _.fuse))
-
-(def: (applysI start amount)
- (-> Register Nat Inst)
- (let [max_args (n.min amount //runtime.num_apply_variants)
- later_applysI (if (n.> //runtime.num_apply_variants amount)
- (applysI (n.+ //runtime.num_apply_variants start) (n.- //runtime.num_apply_variants amount))
- function.identity)]
- (|>> (_.CHECKCAST //.$Function)
- (inputsI start max_args)
- (_.INVOKEVIRTUAL //.$Function //runtime.apply_method (//runtime.apply_signature max_args))
- later_applysI)))
-
-(def: (inc_intI by)
- (-> Nat Inst)
- (|>> (_.int (.int by))
- _.IADD))
-
-(def: (nullsI amount)
- (-> Nat Inst)
- (|> _.NULL
- (list.repeated amount)
- _.fuse))
-
-(def: (instance generate archive class arity env)
- (-> Phase Archive (Type Class) Arity (Environment Synthesis) (Operation Inst))
- (do [@ phase.monad]
- [captureI+ (monad.each @ (generate archive) env)
- .let [argsI (if (poly_arg? arity)
- (|> (nullsI (-- arity))
- (list (_.int +0))
- _.fuse)
- function.identity)]]
- (in (|>> (_.NEW class)
- _.DUP
- (_.fuse captureI+)
- argsI
- (_.INVOKESPECIAL class "<init>" (init_method env arity))))))
-
-(def: (reset_method return)
- (-> (Type Class) (Type Method))
- (type.method [(list) (list) return (list)]))
-
-(def: (with_reset class arity env)
- (-> (Type Class) Arity (Environment Synthesis) Def)
- (def.method {$.#Public} $.noneM "reset" (reset_method class)
- (if (poly_arg? arity)
- (let [env_size (list.size env)
- captureI (|> (case env_size
- 0 (list)
- _ (enum.range n.enum 0 (-- env_size)))
- (list@each (.function (_ source)
- (|>> (_.ALOAD 0)
- (_.GETFIELD class (reference.foreign_name source) //.$Value))))
- _.fuse)
- argsI (|> (nullsI (-- arity))
- (list (_.int +0))
- _.fuse)]
- (|>> (_.NEW class)
- _.DUP
- captureI
- argsI
- (_.INVOKESPECIAL class "<init>" (init_method env arity))
- _.ARETURN))
- (|>> (_.ALOAD 0)
- _.ARETURN))))
-
-(def: (with_implementation arity @begin bodyI)
- (-> Nat Label Inst Def)
- (def.method {$.#Public} $.strictM "impl" (implementation_method arity)
- (|>> (_.label @begin)
- bodyI
- _.ARETURN)))
-
-(def: function_init_method
- (type.method [(list) (list type.int) type.void (list)]))
-
-(def: (function_init arity env_size)
- (-> Arity Nat Inst)
- (if (n.= 1 arity)
- (|>> (_.int +0)
- (_.INVOKESPECIAL //.$Function "<init>" function_init_method))
- (|>> (_.ILOAD (++ env_size))
- (_.INVOKESPECIAL //.$Function "<init>" function_init_method))))
-
-(def: (with_init class env arity)
- (-> (Type Class) (Environment Synthesis) Arity Def)
- (let [env_size (list.size env)
- offset_partial (is (-> Nat Nat)
- (|>> ++ (n.+ env_size)))
- store_capturedI (|> (case env_size
- 0 (list)
- _ (enum.range n.enum 0 (-- env_size)))
- (list@each (.function (_ register)
- (|>> (_.ALOAD 0)
- (_.ALOAD (++ register))
- (_.PUTFIELD class (reference.foreign_name register) //.$Value))))
- _.fuse)
- store_partialI (if (poly_arg? arity)
- (|> (enum.range n.enum 0 (n.- 2 arity))
- (list@each (.function (_ idx)
- (let [register (offset_partial idx)]
- (|>> (_.ALOAD 0)
- (_.ALOAD (++ register))
- (_.PUTFIELD class (reference.partial_name idx) //.$Value)))))
- _.fuse)
- function.identity)]
- (def.method {$.#Public} $.noneM "<init>" (init_method env arity)
- (|>> (_.ALOAD 0)
- (function_init arity env_size)
- store_capturedI
- store_partialI
- _.RETURN))))
-
-(def: (with_apply class env function_arity @begin bodyI apply_arity)
- (-> (Type Class) (Environment Synthesis) Arity Label Inst Arity
- Def)
- (let [num_partials (-- function_arity)
- @default ($.new_label [])
- @labels (list@each $.new_label (list.repeated num_partials []))
- over_extent (|> (.int function_arity) (i.- (.int apply_arity)))
- casesI (|> (list@composite @labels (list @default))
- (list.zipped_2 (enum.range n.enum 0 num_partials))
- (list@each (.function (_ [stage @label])
- (let [load_partialsI (if (n.> 0 stage)
- (|> (enum.range n.enum 0 (-- stage))
- (list@each (|>> reference.partial_name (load_fieldI class)))
- _.fuse)
- function.identity)]
- (cond (i.= over_extent (.int stage))
- (|>> (_.label @label)
- (_.ALOAD 0)
- (pipe.when [(pipe.new (n.> 0 stage) [])]
- [(_.INVOKEVIRTUAL class "reset" (reset_method class))])
- load_partialsI
- (inputsI 1 apply_arity)
- (_.INVOKEVIRTUAL class "impl" (implementation_method function_arity))
- _.ARETURN)
-
- (i.> over_extent (.int stage))
- (let [args_to_completion (|> function_arity (n.- stage))
- args_left (|> apply_arity (n.- args_to_completion))]
- (|>> (_.label @label)
- (_.ALOAD 0)
- (_.INVOKEVIRTUAL class "reset" (reset_method class))
- load_partialsI
- (inputsI 1 args_to_completion)
- (_.INVOKEVIRTUAL class "impl" (implementation_method function_arity))
- (applysI (++ args_to_completion) args_left)
- _.ARETURN))
-
- ... (i.< over_extent (.int stage))
- (let [env_size (list.size env)
- load_capturedI (|> (case env_size
- 0 (list)
- _ (enum.range n.enum 0 (-- env_size)))
- (list@each (|>> reference.foreign_name (load_fieldI class)))
- _.fuse)]
- (|>> (_.label @label)
- (_.NEW class)
- _.DUP
- load_capturedI
- get_amount_of_partialsI
- (inc_intI apply_arity)
- load_partialsI
- (inputsI 1 apply_arity)
- (nullsI (|> num_partials (n.- apply_arity) (n.- stage)))
- (_.INVOKESPECIAL class "<init>" (init_method env function_arity))
- _.ARETURN))
- ))))
- _.fuse)]
- (def.method {$.#Public} $.noneM //runtime.apply_method (//runtime.apply_signature apply_arity)
- (|>> get_amount_of_partialsI
- (_.TABLESWITCH +0 (|> num_partials -- .int)
- @default @labels)
- casesI
- ))))
-
-(def: .public with_environment
- (-> (Environment Synthesis) Def)
- (|>> list.enumeration
- (list@each (.function (_ [env_idx env_source])
- (def.field {$.#Private} $.finalF (reference.foreign_name env_idx) //.$Value)))
- def.fuse))
-
-(def: (with_partial arity)
- (-> Arity Def)
- (if (poly_arg? arity)
- (|> (enum.range n.enum 0 (n.- 2 arity))
- (list@each (.function (_ idx)
- (def.field {$.#Private} $.finalF (reference.partial_name idx) //.$Value)))
- def.fuse)
- function.identity))
-
-(def: .public (with_function generate archive @begin class env arity bodyI)
- (-> Phase Archive Label Text (Environment Synthesis) Arity Inst
- (Operation [Def Inst]))
- (let [classD (type.class class (list))
- applyD (is Def
- (if (poly_arg? arity)
- (|> (n.min arity //runtime.num_apply_variants)
- (enum.range n.enum 1)
- (list@each (with_apply classD env arity @begin bodyI))
- (list& (with_implementation arity @begin bodyI))
- def.fuse)
- (def.method {$.#Public} $.strictM //runtime.apply_method (//runtime.apply_signature 1)
- (|>> (_.label @begin)
- bodyI
- _.ARETURN))))
- functionD (is Def
- (|>> (def.int_field {$.#Public} ($_ $.++F $.staticF $.finalF) arity_field (.int arity))
- (with_environment env)
- (with_partial arity)
- (with_init classD env arity)
- (with_reset classD arity env)
- applyD
- ))]
- (do phase.monad
- [instanceI (..instance generate archive classD arity env)]
- (in [functionD instanceI]))))
-
-(def: .public (function' forced_context generate archive [env arity bodyS])
- (-> (Maybe unit.ID) (Generator Abstraction))
- (do [! phase.monad]
- [@begin _.make_label
- dependencies (cache.dependencies archive bodyS)
- [function_context bodyI] (case forced_context
- {.#Some function_context}
- (do !
- [without_context (generation.with_anchor [@begin 1]
- (generate archive bodyS))]
- (in [function_context
- without_context]))
-
- {.#None}
- (generation.with_new_context archive dependencies
- (generation.with_anchor [@begin 1]
- (generate archive bodyS))))
- .let [function_class (//.class_name function_context)]
- [functionD instanceI] (..with_function generate archive @begin function_class env arity bodyI)
- .let [directive [function_class
- (def.class {$.#V1_6} {$.#Public} $.finalC
- function_class (list)
- //.$Function (list)
- functionD)]]
- _ (generation.execute! directive)
- _ (case forced_context
- {.#None}
- (generation.save! (product.right function_context) {.#None} directive)
-
- {.#Some function_context}
- (in []))]
- (in instanceI)))
-
-(def: .public function
- (Generator Abstraction)
- (..function' {.#None}))
-
-(def: .public (call generate archive [functionS argsS])
- (Generator Apply)
- (do [@ phase.monad]
- [functionI (generate archive functionS)
- argsI (monad.each @ (generate archive) argsS)
- .let [applyI (|> argsI
- (list.sub //runtime.num_apply_variants)
- (list@each (.function (_ subI+)
- (|>> (_.CHECKCAST //.$Function)
- (_.fuse subI+)
- (_.INVOKEVIRTUAL //.$Function //runtime.apply_method (//runtime.apply_signature (list.size subI+))))))
- _.fuse)]]
- (in (|>> functionI
- applyI))))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/loop.lux b/lux-jvm/source/luxc/lang/translation/jvm/loop.lux
deleted file mode 100644
index 4449b3606..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/loop.lux
+++ /dev/null
@@ -1,85 +0,0 @@
-(.using
- [library
- [lux "*"
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" function]]
- [data
- [collection
- ["[0]" list ("[1]@[0]" functor monoid)]]]
- [math
- [number
- ["n" nat]]]
- [tool
- [compiler
- ["[0]" phase]
- [reference
- [variable {"+" Register}]]
- [language
- [lux
- ["[0]" synthesis {"+" Synthesis}]
- ["[0]" generation]]]]]]]
- [luxc
- [lang
- [host
- [jvm {"+" Inst Operation Phase Generator}
- ["_" inst]]]]]
- ["[0]" //])
-
-(def: (invariant? expected actual)
- (-> Register Synthesis Bit)
- (case actual
- (pattern (synthesis.variable/local actual))
- (n.= expected actual)
-
- _
- false))
-
-(def: .public (again translate archive argsS)
- (Generator (List Synthesis))
- (do [@ phase.monad]
- [[@begin start] generation.anchor
- .let [pairs (|> argsS
- list.enumeration
- (list@each (function (_ [register argument])
- [(n.+ start register) argument])))]
- ... It may look weird that first I compile the values separately,
- ... and then I compile the stores/allocations.
- ... It must be done that way in order to avoid a potential bug.
- ... Let's say that you'll recur with 2 expressions: X and Y.
- ... If Y depends on the value of X, and you don't compile values
- ... and stores separately, then by the time Y is evaluated, it
- ... will refer to the new value of X, instead of the old value, and
- ... shouldn't be the case.
- valuesI+ (monad.each @ (function (_ [register argS])
- (is (Operation Inst)
- (if (invariant? register argS)
- (in function.identity)
- (translate archive argS))))
- pairs)
- .let [storesI+ (list@each (function (_ [register argS])
- (is Inst
- (if (invariant? register argS)
- function.identity
- (_.ASTORE register))))
- (list.reversed pairs))]]
- (in (|>> (_.fuse valuesI+)
- (_.fuse storesI+)
- (_.GOTO @begin)))))
-
-(def: .public (scope translate archive [start initsS+ iterationS])
- (Generator [Nat (List Synthesis) Synthesis])
- (do [@ phase.monad]
- [@begin _.make_label
- initsI+ (monad.each @ (translate archive) initsS+)
- iterationI (generation.with_anchor [@begin start]
- (translate archive iterationS))
- .let [initializationI (|> (list.enumeration initsI+)
- (list@each (function (_ [register initI])
- (|>> initI
- (_.ASTORE (n.+ start register)))))
- _.fuse)]]
- (in (|>> initializationI
- (_.label @begin)
- iterationI))))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/primitive.lux b/lux-jvm/source/luxc/lang/translation/jvm/primitive.lux
deleted file mode 100644
index 734b55316..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/primitive.lux
+++ /dev/null
@@ -1,114 +0,0 @@
-(.using
- [library
- [lux {"-" i64}
- ["[0]" ffi {"+" import:}]
- [macro
- ["^" pattern]]
- [math
- [number
- ["i" int]]]
- [target
- [jvm
- ["[0]" type]]]
- [tool
- [compiler
- [phase ("operation@[0]" monad)]]]]]
- [luxc
- [lang
- [host
- ["[0]" jvm {"+" Inst Operation}
- ["_" inst]]]]])
-
-(def: .public bit
- (-> Bit (Operation Inst))
- (let [Boolean (type.class "java.lang.Boolean" (list))]
- (function (_ value)
- (operation@in (_.GETSTATIC Boolean (if value "TRUE" "FALSE") Boolean)))))
-
-(import: java/lang/Byte
- "[1]::[0]"
- ("static" MAX_VALUE byte)
- ("static" MIN_VALUE byte))
-
-(import: java/lang/Short
- "[1]::[0]"
- ("static" MAX_VALUE short)
- ("static" MIN_VALUE short))
-
-(def: .public (i64 value)
- (-> (I64 Any) (Operation Inst))
- (case (.int value)
- (^.template [<int> <instruction>]
- [<int>
- (operation@in (|>> <instruction> (_.wrap type.long)))])
- ([+0 _.LCONST_0]
- [+1 _.LCONST_1])
-
- (^.template [<int> <instruction>]
- [<int>
- (operation@in (|>> <instruction> _.I2L (_.wrap type.long)))])
- ([-1 _.ICONST_M1]
- ... [+0 _.ICONST_0]
- ... [+1 _.ICONST_1]
- [+2 _.ICONST_2]
- [+3 _.ICONST_3]
- [+4 _.ICONST_4]
- [+5 _.ICONST_5])
-
- value
- (let [constantI (cond (and (i.>= (java/lang/Byte::MIN_VALUE) value)
- (i.<= (java/lang/Byte::MAX_VALUE) value))
- (|>> (_.BIPUSH value) _.I2L)
-
- (and (i.>= (java/lang/Short::MIN_VALUE) value)
- (i.<= (java/lang/Short::MAX_VALUE) value))
- (|>> (_.SIPUSH value) _.I2L)
-
- ... else
- (|> value .int _.long))]
- (operation@in (|>> constantI (_.wrap type.long))))))
-
-(import: java/lang/Double
- "[1]::[0]"
- ("static" doubleToRawLongBits "manual" [double] int))
-
-(def: d0-bits
- Int
- (java/lang/Double::doubleToRawLongBits +0.0))
-
-(def: .public (f64 value)
- (-> Frac (Operation Inst))
- (case value
- (^.template [<int> <instruction>]
- [<int>
- (operation@in (|>> <instruction> (_.wrap type.double)))])
- ([+1.0 _.DCONST_1])
-
- (^.template [<int> <instruction>]
- [<int>
- (operation@in (|>> <instruction> _.F2D (_.wrap type.double)))])
- ([+2.0 _.FCONST_2])
-
- (^.template [<int> <instruction>]
- [<int>
- (operation@in (|>> <instruction> _.I2D (_.wrap type.double)))])
- ([-1.0 _.ICONST_M1]
- ... [+0.0 _.ICONST_0]
- ... [+1.0 _.ICONST_1]
- ... [+2.0 _.ICONST_2]
- [+3.0 _.ICONST_3]
- [+4.0 _.ICONST_4]
- [+5.0 _.ICONST_5])
-
- _
- (let [constantI (if (|> value
- (as java/lang/Double)
- java/lang/Double::doubleToRawLongBits
- (i.= ..d0-bits))
- _.DCONST_0
- (_.double value))]
- (operation@in (|>> constantI (_.wrap type.double))))))
-
-(def: .public text
- (-> Text (Operation Inst))
- (|>> _.string operation@in))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/program.lux b/lux-jvm/source/luxc/lang/translation/jvm/program.lux
deleted file mode 100644
index 4efe0fd3d..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/program.lux
+++ /dev/null
@@ -1,94 +0,0 @@
-(.using
- [library
- [lux "*"
- [data
- [text
- ["%" format {"+" format}]]]
- [target
- [jvm
- ["$t" type]]]
- [tool
- [compiler
- [language
- [lux
- [program {"+" Program}]]]
- [meta
- [archive
- ["[0]" unit]]]]]]]
- [luxc
- [lang
- [host
- ["_" jvm
- ["$d" def]
- ["$i" inst]]]
- [translation
- ["[0]" jvm
- ["[0]" runtime]]]]])
-
-(def: ^Object ($t.class "java.lang.Object" (list)))
-
-(def: .public (program artifact_name context programI)
- (-> (-> unit.ID Text) (Program _.Inst _.Definition))
- (let [nilI runtime.noneI
- num_inputsI (|>> ($i.ALOAD 0) $i.ARRAYLENGTH)
- --I (|>> ($i.int +1) $i.ISUB)
- headI (|>> $i.DUP
- ($i.ALOAD 0)
- $i.SWAP
- $i.AALOAD
- $i.SWAP
- $i.DUP_X2
- $i.POP)
- pairI (|>> ($i.int +2)
- ($i.ANEWARRAY ..^Object)
- $i.DUP_X1
- $i.SWAP
- ($i.int +0)
- $i.SWAP
- $i.AASTORE
- $i.DUP_X1
- $i.SWAP
- ($i.int +1)
- $i.SWAP
- $i.AASTORE)
- consI (|>> ($i.int +0)
- ($i.string "")
- $i.DUP2_X1
- $i.POP2
- runtime.variantI)
- prepare_input_listI (<| $i.with_label (function (_ @loop))
- $i.with_label (function (_ @end))
- (|>> nilI
- num_inputsI
- ($i.label @loop)
- --I
- $i.DUP
- ($i.IFLT @end)
- headI
- pairI
- consI
- $i.SWAP
- ($i.GOTO @loop)
- ($i.label @end)
- $i.POP))
- feed_inputsI ($i.INVOKEVIRTUAL jvm.$Function runtime.apply_method (runtime.apply_signature 1))
- run_ioI (|>> ($i.CHECKCAST jvm.$Function)
- $i.NULL
- ($i.INVOKEVIRTUAL jvm.$Function runtime.apply_method (runtime.apply_signature 1)))
- main_type ($t.method [(list)
- (list ($t.array ($t.class "java.lang.String" (list))))
- $t.void
- (list)])
- class (artifact_name context)]
- [class
- ($d.class {_.#V1_6}
- {_.#Public} _.finalC
- class
- (list) ..^Object
- (list)
- (|>> ($d.method {_.#Public} _.staticM "main" main_type
- (|>> programI
- prepare_input_listI
- feed_inputsI
- run_ioI
- $i.RETURN))))]))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/reference.lux b/lux-jvm/source/luxc/lang/translation/jvm/reference.lux
deleted file mode 100644
index 88b2af2ed..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/reference.lux
+++ /dev/null
@@ -1,67 +0,0 @@
-(.using
- [library
- [lux {"-" local}
- [abstract
- [monad {"+" do}]]
- [data
- [text
- ["%" format {"+" format}]]]
- [target
- [jvm
- ["[0]" type]]]
- [tool
- [compiler
- [reference
- ["[0]" variable {"+" Register Variable}]]
- ["[0]" phase ("operation@[0]" monad)]
- [meta
- [archive {"+" Archive}]]
- [language
- [lux
- ["[0]" generation]]]]]]]
- [luxc
- [lang
- [host
- [jvm {"+" Inst Operation}
- ["_" inst]]]]]
- ["[0]" //
- ["[1][0]" runtime]])
-
-(template [<name> <prefix>]
- [(def: .public <name>
- (-> Nat Text)
- (|>> %.nat (format <prefix>)))]
-
- [foreign_name "f"]
- [partial_name "p"]
- )
-
-(def: (foreign archive variable)
- (-> Archive Register (Operation Inst))
- (do [@ phase.monad]
- [class_name (# @ each //.class_name
- (generation.context archive))]
- (in (|>> (_.ALOAD 0)
- (_.GETFIELD (type.class class_name (list))
- (|> variable .nat foreign_name)
- //.$Value)))))
-
-(def: local
- (-> Register Inst)
- (|>> _.ALOAD))
-
-(def: .public (variable archive variable)
- (-> Archive Variable (Operation Inst))
- (case variable
- {variable.#Local variable}
- (operation@in (local variable))
-
- {variable.#Foreign variable}
- (foreign archive variable)))
-
-(def: .public (constant archive name)
- (-> Archive Symbol (Operation Inst))
- (do [@ phase.monad]
- [class_name (# @ each //.class_name
- (generation.remember archive name))]
- (in (_.GETSTATIC (type.class class_name (list)) //.value_field //.$Value))))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/runtime.lux b/lux-jvm/source/luxc/lang/translation/jvm/runtime.lux
deleted file mode 100644
index 76c170725..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/runtime.lux
+++ /dev/null
@@ -1,425 +0,0 @@
-(.using
- [library
- [lux {"-" Type Label Primitive try}
- [abstract
- [monad {"+" do}]
- ["[0]" enum]]
- [data
- [binary {"+" Binary}]
- ["[0]" product]
- [text
- ["%" format {"+" format}]]
- [collection
- ["[0]" list ("[1]@[0]" functor)]
- ["[0]" sequence]
- ["[0]" set]]]
- ["[0]" math
- [number
- ["n" nat]]]
- [target
- [jvm
- ["[0]" type {"+" Type}
- ["[0]" category {"+" Void Value' Value Return' Return Primitive Object Class Array Var Parameter Method}]
- ["[0]" reflection]]]]
- [tool
- [compiler
- [arity {"+" Arity}]
- ["[0]" phase]
- [language
- [lux
- ["[0]" synthesis]
- ["[0]" generation]]]
- [meta
- [archive {"+" Output}
- ["[0]" artifact]
- ["[0]" registry {"+" Registry}]
- ["[0]" unit]]]]]]]
- [luxc
- [lang
- [host
- ["$" jvm {"+" Label Inst Def Operation}
- ["$d" def]
- ["_" inst]]]]]
- ["[0]" // {"+" ByteCode}])
-
-(def: $Text (type.class "java.lang.String" (list)))
-(def: .public $Lefts type.int)
-(def: .public $Right? (type.class "java.lang.Object" (list)))
-(def: .public $Value (type.class "java.lang.Object" (list)))
-(def: .public $Index type.int)
-(def: .public $Stack (type.array $Value))
-(def: $Throwable (type.class "java.lang.Throwable" (list)))
-
-(def: nullary_init_methodT
- (type.method [(list) (list) type.void (list)]))
-
-(def: throw_methodT
- (type.method [(list) (list) type.void (list)]))
-
-(def: .public logI
- Inst
- (let [PrintStream (type.class "java.io.PrintStream" (list))
- outI (_.GETSTATIC (type.class "java.lang.System" (list)) "out" PrintStream)
- printI (function (_ method)
- (_.INVOKEVIRTUAL PrintStream method (type.method [(list) (list $Value) type.void (list)])))]
- (|>> outI (_.string "LOG: ") (printI "print")
- outI _.SWAP (printI "println"))))
-
-(def: variant_method
- (type.method [(list) (list $Lefts $Right? $Value) //.$Variant (list)]))
-
-(def: .public variantI
- Inst
- (_.INVOKESTATIC //.$Runtime "variant_make" variant_method))
-
-(def: .public leftI
- Inst
- (|>> _.ICONST_0
- _.NULL
- _.DUP2_X1
- _.POP2
- variantI))
-
-(def: .public rightI
- Inst
- (|>> _.ICONST_0
- (_.string "")
- _.DUP2_X1
- _.POP2
- variantI))
-
-(def: .public someI Inst rightI)
-
-(def: .public noneI
- Inst
- (|>> _.ICONST_0
- _.NULL
- (_.string synthesis.unit)
- variantI))
-
-(def: (tryI unsafeI)
- (-> Inst Inst)
- (<| _.with_label (function (_ @from))
- _.with_label (function (_ @to))
- _.with_label (function (_ @handler))
- (|>> (_.try @from @to @handler (type.class "java.lang.Exception" (list)))
- (_.label @from)
- unsafeI
- someI
- _.ARETURN
- (_.label @to)
- (_.label @handler)
- noneI
- _.ARETURN)))
-
-(def: .public partials_field Text "partials")
-(def: .public apply_method Text "apply")
-(def: .public num_apply_variants Nat 8)
-
-(def: .public (apply_signature arity)
- (-> Arity (Type Method))
- (type.method [(list) (list.repeated arity $Value) $Value (list)]))
-
-(def: adt_methods
- Def
- (let [store_leftsI (|>> _.DUP _.ICONST_0 (_.ILOAD 0) (_.wrap type.int) _.AASTORE)
- store_flagI (|>> _.DUP _.ICONST_1 (_.ALOAD 1) _.AASTORE)
- store_valueI (|>> _.DUP _.ICONST_2 (_.ALOAD 2) _.AASTORE)]
- (|>> ($d.method {$.#Public} $.staticM "variant_make"
- (type.method [(list) (list $Lefts $Right? $Value) //.$Variant (list)])
- (|>> _.ICONST_3
- (_.ANEWARRAY $Value)
- store_leftsI
- store_flagI
- store_valueI
- _.ARETURN)))))
-
-(def: frac_methods
- Def
- (|>> ($d.method {$.#Public} $.staticM "decode_frac" (type.method [(list) (list $Text) //.$Variant (list)])
- (tryI
- (|>> (_.ALOAD 0)
- (_.INVOKESTATIC (type.class "java.lang.Double" (list)) "parseDouble" (type.method [(list) (list $Text) type.double (list)]))
- (_.wrap type.double))))
- ))
-
-(def: (illegal_state_exception message)
- (-> Text Inst)
- (let [IllegalStateException (type.class "java.lang.IllegalStateException" (list))]
- (|>> (_.NEW IllegalStateException)
- _.DUP
- (_.string message)
- (_.INVOKESPECIAL IllegalStateException "<init>" (type.method [(list) (list $Text) type.void (list)])))))
-
-(def: pm_methods
- Def
- (let [tuple_sizeI (|>> (_.ALOAD 0)
- _.ARRAYLENGTH)
- last_rightI (|>> tuple_sizeI
- _.ICONST_1
- _.ISUB)
- leftsI (_.ILOAD 1)
- left_indexI leftsI
- sub_leftsI (|>> leftsI
- last_rightI
- _.ISUB)
- sub_tupleI (|>> (_.ALOAD 0)
- last_rightI
- _.AALOAD
- (_.CHECKCAST //.$Tuple))
- recurI (is (-> Label Inst)
- (function (_ @loop)
- (|>> sub_leftsI (_.ISTORE 1)
- sub_tupleI (_.ASTORE 0)
- (_.GOTO @loop))))]
- (|>> ($d.method {$.#Public} $.staticM "pm_fail" throw_methodT
- (|>> (illegal_state_exception "Invalid expression for pattern-matching.")
- _.ATHROW))
- ($d.method {$.#Public} $.staticM "apply_fail" throw_methodT
- (|>> (illegal_state_exception "Error while applying function.")
- _.ATHROW))
- ($d.method {$.#Public} $.staticM "pm_push" (type.method [(list) (list $Stack $Value) $Stack (list)])
- (|>> _.ICONST_2
- (_.ANEWARRAY $Value)
- _.DUP
- _.ICONST_1
- (_.ALOAD 0)
- _.AASTORE
- _.DUP
- _.ICONST_0
- (_.ALOAD 1)
- _.AASTORE
- _.ARETURN))
- ($d.method {$.#Public} $.staticM "pm_variant" (type.method [(list) (list //.$Variant $Lefts $Right?) $Value (list)])
- (<| _.with_label (function (_ @loop))
- _.with_label (function (_ @perfect_match!))
- _.with_label (function (_ @lefts_match!))
- _.with_label (function (_ @maybe_nested))
- _.with_label (function (_ @mismatch!))
- (let [$variant (_.ALOAD 0)
- $lefts (_.ILOAD 1)
- $right? (_.ALOAD 2)
-
- variant_partI (is (-> Nat Inst)
- (function (_ idx)
- (|>> (_.int (.int idx)) _.AALOAD)))
- ::lefts (is Inst
- (|>> (variant_partI 0)
- (_.unwrap type.int)))
- ::right? (variant_partI 1)
- ::value (variant_partI 2)
-
- not_found _.NULL
-
- super_nested_lefts (|>> _.SWAP ... variant::lefts, lefts
- _.ISUB
- (_.int +1)
- _.ISUB)
- super_nested (|>> super_nested_lefts ... super_lefts
- $variant ::right? ... super_lefts, super_right?
- $variant ::value ... super_lefts, super_right?, super_value
- ..variantI)
-
- update_$variant (|>> $variant ::value
- (_.CHECKCAST //.$Variant)
- (_.ASTORE 0))
- update_$lefts (|>> _.ISUB
- (_.int +1)
- _.ISUB)
- iterate! (is (-> Label Inst)
- (function (_ @loop)
- (|>> update_$variant
- update_$lefts
- (_.GOTO @loop))))])
- (|>> $lefts ... lefts
- (_.label @loop)
- $variant ::lefts ... lefts, variant::lefts
- _.DUP2 (_.IF_ICMPEQ @lefts_match!) ... lefts, variant::lefts
- _.DUP2 (_.IF_ICMPGT @maybe_nested) ... lefts, variant::lefts
- $right? (_.IFNULL @mismatch!) ... lefts, variant::lefts
- super_nested ... super_variant
- _.ARETURN
- ...........................
- ...... @lefts_match! ......
- ...........................
- (_.label @lefts_match!) ... lefts, variant::lefts
- $right? ... lefts, variant::lefts, right?
- $variant ::right? ... lefts, variant::lefts, right?, variant::right?
- (_.IF_ACMPEQ @perfect_match!) ... lefts, variant::lefts
- ........................
- ...... @mismatch! ......
- ........................
- (_.label @mismatch!) ... lefts, variant::lefts
- ... _.POP2
- not_found
- _.ARETURN
- (_.label @maybe_nested) ... lefts, variant::lefts
- $variant ::right? ... lefts, variant::lefts, variant::right?
- (_.IFNULL @mismatch!) ... lefts, variant::lefts
- (iterate! @loop)
- .............................
- ...... @perfect_match! ......
- .............................
- (_.label @perfect_match!) ... lefts, variant::lefts
- ... _.POP2
- $variant ::value
- _.ARETURN)))
- ($d.method {$.#Public} $.staticM "tuple_left" (type.method [(list) (list //.$Tuple $Index) $Value (list)])
- (<| _.with_label (function (_ @loop))
- _.with_label (function (_ @recursive))
- (let [left_accessI (|>> (_.ALOAD 0) left_indexI _.AALOAD)])
- (|>> (_.label @loop)
- leftsI last_rightI (_.IF_ICMPGE @recursive)
- left_accessI
- _.ARETURN
- (_.label @recursive)
- ... Recursive
- (recurI @loop))))
- ($d.method {$.#Public} $.staticM "tuple_right" (type.method [(list) (list //.$Tuple $Index) $Value (list)])
- (<| _.with_label (function (_ @loop))
- _.with_label (function (_ @not_tail))
- _.with_label (function (_ @slice))
- (let [right_indexI (|>> leftsI
- _.ICONST_1
- _.IADD)
- right_accessI (|>> (_.ALOAD 0)
- _.SWAP
- _.AALOAD)
- sub_rightI (|>> (_.ALOAD 0)
- right_indexI
- tuple_sizeI
- (_.INVOKESTATIC (type.class "java.util.Arrays" (list)) "copyOfRange"
- (type.method [(list)
- (list //.$Tuple $Index $Index)
- //.$Tuple
- (list)])))])
- (|>> (_.label @loop)
- last_rightI right_indexI
- _.DUP2 (_.IF_ICMPNE @not_tail)
- ... _.POP
- right_accessI
- _.ARETURN
- (_.label @not_tail)
- (_.IF_ICMPGT @slice)
- ... Must recurse
- (recurI @loop)
- (_.label @slice)
- sub_rightI
- _.ARETURN
- )))
- )))
-
-(def: .public try
- (type.method [(list) (list //.$Function) //.$Variant (list)]))
-
-(def: io_methods
- Def
- (let [StringWriter (type.class "java.io.StringWriter" (list))
- PrintWriter (type.class "java.io.PrintWriter" (list))
- string_writerI (|>> (_.NEW StringWriter)
- _.DUP
- (_.INVOKESPECIAL StringWriter "<init>" nullary_init_methodT))
- print_writerI (|>> (_.NEW PrintWriter)
- _.SWAP
- _.DUP2
- _.POP
- _.SWAP
- (_.boolean true)
- (_.INVOKESPECIAL PrintWriter "<init>" (type.method [(list) (list (type.class "java.io.Writer" (list)) type.boolean) type.void (list)]))
- )]
- (|>> ($d.method {$.#Public} $.staticM "try" ..try
- (<| _.with_label (function (_ @from))
- _.with_label (function (_ @to))
- _.with_label (function (_ @handler))
- (|>> (_.try @from @to @handler $Throwable)
- (_.label @from)
- (_.ALOAD 0)
- _.NULL
- (_.INVOKEVIRTUAL //.$Function apply_method (apply_signature 1))
- rightI
- _.ARETURN
- (_.label @to)
- (_.label @handler)
- string_writerI ... TW
- _.DUP2 ... TWTW
- print_writerI ... TWTP
- (_.INVOKEVIRTUAL $Throwable "printStackTrace" (type.method [(list) (list (type.class "java.io.PrintWriter" (list))) type.void (list)])) ... TW
- (_.INVOKEVIRTUAL StringWriter "toString" (type.method [(list) (list) $Text (list)])) ... TS
- _.SWAP _.POP leftI
- _.ARETURN)))
- )))
-
-(def: reflection
- (All (_ category)
- (-> (Type (<| Return' Value' category)) Text))
- (|>> type.reflection reflection.reflection))
-
-(def: runtime_id
- 0)
-
-(def: translate_runtime
- (Operation [artifact.ID (Maybe Text) Binary])
- (let [runtime_class (..reflection //.$Runtime)
- bytecode ($d.class {$.#V1_6} {$.#Public} $.finalC runtime_class (list) (type.class "java.lang.Object" (list)) (list)
- (|>> adt_methods
- frac_methods
- pm_methods
- io_methods))
- directive [runtime_class bytecode]]
- (do phase.monad
- [_ (generation.execute! directive)
- _ (generation.save! ..runtime_id {.#None} directive)]
- (in [..runtime_id {.#None} bytecode]))))
-
-(def: function_id
- 1)
-
-(def: translate_function
- (Operation [artifact.ID (Maybe Text) Binary])
- (let [applyI (|> (enum.range n.enum 2 num_apply_variants)
- (list@each (function (_ arity)
- ($d.method {$.#Public} $.noneM apply_method (apply_signature arity)
- (let [preI (|> (enum.range n.enum 0 (-- arity))
- (list@each _.ALOAD)
- _.fuse)]
- (|>> preI
- (_.INVOKEVIRTUAL //.$Function apply_method (apply_signature (-- arity)))
- (_.CHECKCAST //.$Function)
- (_.ALOAD arity)
- (_.INVOKEVIRTUAL //.$Function apply_method (apply_signature 1))
- _.ARETURN)))))
- (list& ($d.abstract_method {$.#Public} $.noneM apply_method (apply_signature 1)))
- $d.fuse)
- $Object (type.class "java.lang.Object" (list))
- function_class (..reflection //.$Function)
- bytecode ($d.abstract {$.#V1_6} {$.#Public} $.noneC function_class (list) $Object (list)
- (|>> ($d.field {$.#Public} $.finalF partials_field type.int)
- ($d.method {$.#Public} $.noneM "<init>" (type.method [(list) (list type.int) type.void (list)])
- (|>> (_.ALOAD 0)
- (_.INVOKESPECIAL $Object "<init>" nullary_init_methodT)
- (_.ALOAD 0)
- (_.ILOAD 1)
- (_.PUTFIELD //.$Function partials_field type.int)
- _.RETURN))
- applyI))
- directive [function_class bytecode]]
- (do phase.monad
- [_ (generation.execute! directive)
- _ (generation.save! ..function_id {.#None} directive)]
- (in [..function_id {.#None} bytecode]))))
-
-(def: .public translate
- (Operation [Registry Output])
- (do phase.monad
- [runtime_payload ..translate_runtime
- ... function_payload ..translate_function
- ]
- (in [(|> registry.empty
- (registry.resource true unit.none)
- product.right
- ... (registry.resource true unit.none)
- ... product.right
- )
- (sequence.sequence runtime_payload
- ... function_payload
- )])))
diff --git a/lux-jvm/source/luxc/lang/translation/jvm/structure.lux b/lux-jvm/source/luxc/lang/translation/jvm/structure.lux
deleted file mode 100644
index 878658efe..000000000
--- a/lux-jvm/source/luxc/lang/translation/jvm/structure.lux
+++ /dev/null
@@ -1,118 +0,0 @@
-(.using
- [library
- [lux {"-" Type Primitive}
- ["[0]" ffi {"+" import:}]
- [abstract
- ["[0]" monad {"+" do}]]
- [control
- ["[0]" exception {"+" exception:}]]
- [data
- [text
- ["%" format {"+" format}]]
- [collection
- ["[0]" list]]]
- [math
- [number
- ["n" nat]
- ["i" int]]]
- [target
- [jvm
- ["[0]" type {"+" Type}
- ["[0]" category {"+" Void Value Return Primitive Object Class Array Var Parameter Method}]
- ["[0]" descriptor {"+" Descriptor}]
- ["[0]" signature {"+" Signature}]]]]
- [tool
- [compiler
- ["[0]" phase]
- [meta
- [archive {"+" Archive}]]
- [language
- [lux
- [synthesis {"+" Synthesis}]]]]]]]
- [luxc
- [lang
- [host
- [jvm {"+" Inst Operation Phase Generator}
- ["_" inst]]]]]
- ["[0]" //
- ["[1][0]" runtime]])
-
-(exception: .public (not_a_tuple [size Nat])
- (exception.report
- "Expected size" ">= 2"
- "Actual size" (%.nat size)))
-
-(def: .public (tuple generate archive members)
- (Generator (List Synthesis))
- (do [@ phase.monad]
- [.let [size (list.size members)]
- _ (phase.assertion ..not_a_tuple size
- (n.>= 2 size))
- membersI (|> members
- list.enumeration
- (monad.each @ (function (_ [idx member])
- (do @
- [memberI (generate archive member)]
- (in (|>> _.DUP
- (_.int (.int idx))
- memberI
- _.AASTORE)))))
- (# @ each _.fuse))]
- (in (|>> (_.int (.int size))
- (_.array //runtime.$Value)
- membersI))))
-
-(import: java/lang/Byte
- "[1]::[0]"
- ("static" MAX_VALUE byte)
- ("static" MIN_VALUE byte))
-
-(import: java/lang/Short
- "[1]::[0]"
- ("static" MAX_VALUE short)
- ("static" MIN_VALUE short))
-
-(def: .public (tagI lefts right?)
- (-> Nat Bit Inst)
- (case lefts
- 0 _.ICONST_0
- 1 _.ICONST_1
- 2 _.ICONST_2
- 3 _.ICONST_3
- 4 _.ICONST_4
- 5 _.ICONST_5
- tag (let [tag (.int tag)]
- (cond (and (i.>= (java/lang/Byte::MIN_VALUE) tag)
- (i.<= (java/lang/Byte::MAX_VALUE) tag))
- (_.BIPUSH tag)
-
- (and (i.>= (java/lang/Short::MIN_VALUE) tag)
- (i.<= (java/lang/Short::MAX_VALUE) tag))
- (_.SIPUSH tag)
-
- ... else
- (_.int tag)))))
-
-(def: .public leftI _.NULL)
-(def: .public rightI (_.string ""))
-
-(def: .public (flagI right?)
- (-> Bit Inst)
- (if right?
- ..rightI
- ..leftI))
-
-(def: .public (variant generate archive [lefts right? member])
- (Generator [Nat Bit Synthesis])
- (do phase.monad
- [memberI (generate archive member)
- .let [tagI (..tagI lefts right?)]]
- (in (|>> tagI
- (flagI right?)
- memberI
- (_.INVOKESTATIC //.$Runtime
- "variant_make"
- (type.method [(list)
- (list //runtime.$Lefts //runtime.$Right? //runtime.$Value)
- //.$Variant
- (list)]))))))
diff --git a/lux-jvm/source/program.lux b/lux-jvm/source/program.lux
index 61593c215..c1f70ec10 100644
--- a/lux-jvm/source/program.lux
+++ b/lux-jvm/source/program.lux
@@ -1,102 +1,81 @@
(.using
- [library
- [lux {"-" Definition}
- [program {"+" program:}]
- ["@" target]
- ["[0]" ffi {"+" import:}]
- [abstract
- [monad {"+" do}]]
- [control
- ["[0]" io {"+" IO}]
- ["[0]" try {"+" Try}]
- [concurrency
- ["[0]" async {"+" Async}]]]
- [data
- ["[0]" product]
- [text
- ["%" format {"+" format}]]
- [collection
- [array {"+" Array}]
- ["[0]" dictionary]]]
- ["[0]" world "_"
- ["[0]" file]
- ["[1]/[0]" program]]
- [target
- ["[0]" jvm "_"
- [bytecode {"+" Bytecode}]
- ["[1]/[0]" type
- ["[1]/[0]" box]]]]
- [tool
- [compiler
- [reference {"+" }]
- ["[0]" phase]
- [default
- ["[0]" platform {"+" Platform}]]
- [meta
- [archive {"+" Archive}]
- ["[0]" packager "_"
- ["[1]" jvm]]]
- [language
- [lux
- ["$" synthesis {"+" Synthesis}]
- ["[0]" generation]
- [analysis
- [macro {"+" Expander}]]
- [phase
- [extension {"+" Phase Bundle Operation Handler Extender}
- ["[0]" analysis "_"
- ["[1]" jvm]]
- ... ["[0]" generation "_"
- ... ["[1]" jvm]]
- ... ["[0]" directive "_"
- ... ["[1]" jvm]]
- ]
- [generation
- ["[0]" jvm "_"
- ["[1]/[0]" runtime]
- ... ["[1]/[0]" host]
- ]]]]]]]]]
- [program
- ["/" compositor
- ["/[0]" cli]
- ["/[0]" static]]]
- [luxc
- [lang
- [host
- ["_" jvm]]
- ["[0]" directive "_"
- ["[1]" jvm]]
- [translation
- ["[0]" jvm
- ["[0]" runtime]
- ["[0]" expression]
- ["[0]" function]
- ["[1]/[0]" program]
- ["translation" extension]]]]])
+ [library
+ [lux {"-" Definition}
+ [program {"+" program:}]
+ ["@" target]
+ ["[0]" ffi {"+" import:}]
+ [abstract
+ [monad {"+" do}]]
+ [control
+ ["[0]" io {"+" IO}]
+ ["[0]" try {"+" Try}]
+ [concurrency
+ ["[0]" async {"+" Async}]]]
+ [data
+ ["[0]" product]
+ [text
+ ["%" format {"+" format}]]
+ [collection
+ [array {"+" Array}]]]
+ ["[0]" world "_"
+ ["[0]" file]
+ ["[1]/[0]" program]]
+ [target
+ ["[0]" jvm "_"
+ [bytecode {"+" Bytecode}]
+ ["[1]/[0]" type
+ ["[1]/[0]" box]]]]
+ [tool
+ [compiler {"+"}
+ ["[0]" phase]
+ [default
+ ["[0]" platform {"+" Platform}]]
+ [meta
+ [archive {"+" Archive}]
+ ["[0]" context]
+ ["[0]" cli]
+ ["[0]" packager "_"
+ ["[1]" jvm]]]
+ [language
+ [lux
+ [generation {"+" Operation}]
+ [analysis
+ [macro {"+" Expander}]]
+ [phase
+ ["[0]" extension
+ ["[0]" analysis "_"
+ ["[1]" jvm]]
+ ["[0]" generation "_"
+ ["[1]" jvm]]
+ ["[0]" directive "_"
+ ["[1]" jvm]]]
+ [generation
+ ["/" jvm
+ ["[1][0]" runtime {"+" Anchor Definition}]
+ ["[1][0]" host]
+ ["[1][0]" program]]]]]]]]]]
+ [program
+ ["[0]" compositor]])
(import: java/lang/reflect/Method
- ["[1]::[0]"
- (invoke [java/lang/Object [java/lang/Object]] "try" java/lang/Object)])
+ "[1]::[0]"
+ (invoke [java/lang/Object [java/lang/Object]] "try" java/lang/Object))
-(import: java/lang/ClassLoader)
+(import: java/lang/ClassLoader
+ "[1]::[0]")
(import: (java/lang/Class c)
- ["[1]::[0]"
- (getMethod [java/lang/String [(java/lang/Class java/lang/Object)]] "try" java/lang/reflect/Method)])
+ "[1]::[0]"
+ (getMethod [java/lang/String [(java/lang/Class java/lang/Object)]] "try" java/lang/reflect/Method))
(import: java/lang/Object
- ["[1]::[0]"
- (getClass [] (java/lang/Class java/lang/Object))])
+ "[1]::[0]"
+ (getClass [] (java/lang/Class java/lang/Object)))
(def: _object_class
(java/lang/Class java/lang/Object)
(ffi.class_for java/lang/Object))
-(def: _apply1_args
- (Array (java/lang/Class java/lang/Object))
- (|> (ffi.array (java/lang/Class java/lang/Object) 1)
- (ffi.write! 0 _object_class)))
-
(def: _apply2_args
(Array (java/lang/Class java/lang/Object))
(|> (ffi.array (java/lang/Class java/lang/Object) 2)
@@ -116,192 +95,92 @@
Expander
(do try.monad
[apply_method (|> macro
- (:as java/lang/Object)
+ (as java/lang/Object)
(java/lang/Object::getClass)
(java/lang/Class::getMethod "apply" _apply2_args))]
- (:as (Try (Try [Lux (List Code)]))
- (java/lang/reflect/Method::invoke
- (:as java/lang/Object macro)
- (|> (ffi.array java/lang/Object 2)
- (ffi.write! 0 (:as java/lang/Object inputs))
- (ffi.write! 1 (:as java/lang/Object lux)))
- apply_method))))
-
-... DEPRECATED
-... (def: how_to_wrap_a_phase
-... Synthesis
-... (let [java/lang/String (jvm/type.class "java.lang.String" (list))
-... <java/lang/Class> (jvm/type.array (jvm/type.class "java.lang.Class" (list)))
-... java/lang/Object (jvm/type.class "java.lang.Object" (list))
-... <java/lang/Object> (jvm/type.array java/lang/Object)
-
-... jvm_type (: (All (_ c) (-> (jvm/type.Type c) Synthesis))
-... (|>> jvm/type.format
-... $.text))
-... class_type (: (-> Text Synthesis)
-... (function (_ name)
-... (|> (jvm/type.class name (list))
-... jvm_type)))
-... unwrap_long (: (-> Synthesis Synthesis)
-... (|>> (list ($.text jvm/type/box.long)
-... ($.text "long"))
-... {$.#Extension "jvm object cast"}))
-... long_to_int (: (-> Synthesis Synthesis)
-... (|>> (list)
-... {$.#Extension "jvm conversion long-to-int"}))
-... literal_nat (: (-> Nat Synthesis)
-... (|>> .i64 $.i64 unwrap_long long_to_int))
-... write! (: (-> Text Nat Synthesis Synthesis Synthesis)
-... (function (_ element_class index value array)
-... {$.#Extension "jvm array write object"
-... (list (jvm_type (jvm/type.array (jvm/type.class element_class (list))))
-... (literal_nat index)
-... value
-... array)}))
-... object_array (: (-> Text Nat Synthesis)
-... (function (_ class_name size)
-... {$.#Extension "jvm array new object"
-... (list (class_type class_name)
-... (literal_nat size))}))
-... class_of (: (-> Synthesis Synthesis)
-... (function (_ object)
-... {$.#Extension "jvm member invoke virtual"
-... (list& (class_type "java.lang.Object")
-... ($.text "getClass")
-... (class_type "java.lang.Class")
-... object
-... (list))}))
-... input (: (All (_ c) (-> (jvm/type.Type c) Synthesis Synthesis))
-... (function (_ value_type value)
-... ($.tuple (list (jvm_type value_type) value))))
-
-... example_object {$.#Extension "jvm member invoke constructor"
-... (list& (class_type "java.lang.Object")
-... (list))}
-... phase_arity 3
-... $phase ($.variable/local 1)
-... $archive ($.variable/local 2)
-... $input ($.variable/local 3)
-... $state ($.variable/local 4)
-... apply_method {$.#Extension "jvm member invoke virtual"
-... (list& (class_type "java.lang.Class")
-... ($.text "getMethod")
-... (class_type "java.lang.reflect.Method")
-... (class_of $phase)
-... (list (input java/lang/String
-... ($.text runtime.apply_method))
-... (input <java/lang/Class>
-... (|> (object_array "java.lang.Class" phase_arity)
-... (write! "java.lang.Class" 0 (class_of example_object))
-... (write! "java.lang.Class" 1 (class_of example_object))
-... (write! "java.lang.Class" 2 (class_of example_object))))))}]
-... {$.#Extension "jvm member invoke virtual"
-... (list& (class_type "java.lang.reflect.Method")
-... ($.text "invoke")
-... (class_type "java.lang.Object")
-... apply_method
-... (list (input java/lang/Object
-... $phase)
-... (input <java/lang/Object>
-... (|> (object_array "java.lang.Object" phase_arity)
-... (write! "java.lang.Object" 0 $archive)
-... (write! "java.lang.Object" 1 $input)
-... (write! "java.lang.Object" 2 $state)))))}))
+ (as (Try (Try [Lux (List Code)]))
+ (java/lang/reflect/Method::invoke
+ (as java/lang/Object macro)
+ (|> (ffi.array java/lang/Object 2)
+ (ffi.write! 0 (as java/lang/Object inputs))
+ (ffi.write! 1 (as java/lang/Object lux)))
+ apply_method))))
(def: (phase_wrapper archive)
- (-> Archive (generation.Operation _.Anchor _.Inst _.Definition phase.Wrapper))
- (do phase.monad
- [... instanceG (function.function' {.#Some [0 (.nat -1)]} expression.translate archive [(list) 4 ..how_to_wrap_a_phase])
- ... phase_wrapper (generation.evaluate! [0 (.nat -2)] instanceG)
- ]
- (in (|>>)
- ... (function (_ phase)
- ... (<| try.trusted
- ... (: (Try java/lang/Object))
- ... (do try.monad
- ... [apply_method (|> phase_wrapper
- ... (:as java/lang/Object)
- ... (java/lang/Object::getClass)
- ... (java/lang/Class::getMethod runtime.apply_method _apply1_args))]
- ... (java/lang/reflect/Method::invoke
- ... (:as java/lang/Object phase_wrapper)
- ... (|> (ffi.array java/lang/Object 1)
- ... (ffi.write! 0 (:as java/lang/Object phase)))
- ... apply_method))))
- )))
+ (-> Archive (Operation Anchor (Bytecode Any) Definition phase.Wrapper))
+ (# phase.monad in (|>>)))
(def: .public platform
- ... (IO (Platform Anchor (Bytecode Any) Definition))
(IO [java/lang/ClassLoader
- (Platform _.Anchor _.Inst _.Definition)])
+ /runtime.Host
+ (Platform Anchor (Bytecode Any) Definition)])
(do io.monad
- [... host jvm/host.host
- [loader host] jvm.host]
+ [[loader host] /host.host]
(in [loader
+ host
[platform.#&file_system (file.async file.default)
platform.#host host
- ... platform.#phase jvm.generate
- platform.#phase expression.translate
- ... platform.#runtime runtime.generate
- platform.#runtime runtime.translate
+
+ platform.#phase /.generate
+ platform.#runtime /runtime.generate
+
platform.#phase_wrapper ..phase_wrapper
platform.#write product.right]])))
(def: (extender phase_wrapper)
- (-> phase.Wrapper Extender)
+ (-> phase.Wrapper extension.Extender)
... TODO: Stop relying on coercions ASAP.
- (<| (:as Extender)
+ (<| (as extension.Extender)
(function (@self handler))
- (:as Handler)
+ (as extension.Handler)
(function (@self name phase))
- (:as Phase)
+ (as extension.Phase)
(function (@self archive parameters))
- (:as Operation)
+ (as extension.Operation)
(function (@self state))
- (:as Try)
+ (as Try)
try.trusted
- (:as Try)
+ (as Try)
(do try.monad
[method (|> handler
- (:as java/lang/Object)
+ (as java/lang/Object)
(java/lang/Object::getClass)
(java/lang/Class::getMethod "apply" _apply5_args))]
(java/lang/reflect/Method::invoke
- (:as java/lang/Object handler)
+ (as java/lang/Object handler)
(|> (ffi.array java/lang/Object 5)
- (ffi.write! 0 (:as java/lang/Object name))
- (ffi.write! 1 (:as java/lang/Object (phase_wrapper phase)))
- (ffi.write! 2 (:as java/lang/Object archive))
- (ffi.write! 3 (:as java/lang/Object parameters))
- (ffi.write! 4 (:as java/lang/Object state)))
+ (ffi.write! 0 (as java/lang/Object name))
+ (ffi.write! 1 (as java/lang/Object (phase_wrapper phase)))
+ (ffi.write! 2 (as java/lang/Object archive))
+ (ffi.write! 3 (as java/lang/Object parameters))
+ (ffi.write! 4 (as java/lang/Object state)))
method))))
(def: (declare_success! _)
(-> Any (Async Any))
(async.future (# world/program.default exit +0)))
-(program: [service /cli.service]
- (let [static [/static.#host @.jvm
- /static.#host_module_extension ".jvm"
- /static.#target (/cli.target service)
- /static.#artifact_extension ".class"]]
+(def: (lux_compiler it)
+ (-> Any platform.Custom)
+ (as_expected it))
+
+(program: [service cli.service]
+ (let [context (context.jvm (cli.target service))]
(exec (do async.monad
- [[loader platform] (async.future ..platform)
- _ (/.compiler [/static.#host @.jvm
- /static.#host_module_extension ".jvm"
- /static.#target (/cli.target service)
- /static.#artifact_extension ".class"]
- ..expander
- (analysis.bundle loader)
- (io.io platform)
- ... generation.bundle
- translation.bundle
- (|>> ..extender (directive.bundle loader))
- (jvm/program.program jvm/runtime.class_name)
- [_.Anchor _.Inst _.Definition]
- ..extender
- service
- [(packager.package static)
- (format (/cli.target service) (# file.default separator) "program.jar")])]
+ [[loader host platform] (async.future ..platform)
+ _ (compositor.compiler
+ ..lux_compiler
+ context
+ ..expander
+ (analysis.bundle loader host)
+ (io.io platform)
+ generation.bundle
+ (|>> ..extender (directive.bundle loader))
+ (/program.program /runtime.class_name)
+ [Anchor (type (Bytecode Any)) Definition]
+ ..extender
+ service
+ [(packager.package context)
+ (format (cli.target service) (# file.default separator) "program.jar")])]
(..declare_success! []))
(io.io []))))
diff --git a/lux-jvm/source/test/program.lux b/lux-jvm/source/test/program.lux
deleted file mode 100644
index 112225a56..000000000
--- a/lux-jvm/source/test/program.lux
+++ /dev/null
@@ -1,18 +0,0 @@
-(.using
- [lux "*"
- ["_" test {"+" Test}]
- [control
- ["[0]" io]
- [parser
- [cli {"+" program:}]]]]
- [spec
- ["[0]" compositor]]
- [\\
- ["[0]" /]])
-
-(program: args
- (<| io.io
- _.run!
- ... (_.times 100)
- (_.seed 1985013625126912890)
- (compositor.spec /.jvm /.bundle /.expander /.program)))
diff --git a/lux-python/commands.md b/lux-python/commands.md
index 3340581a2..869413fa7 100644
--- a/lux-python/commands.md
+++ b/lux-python/commands.md
@@ -28,6 +28,14 @@ cd ~/lux/stdlib/ \
```
cd ~/lux/lux-python/ \
-&& mvn install:install-file -Dfile=target/program.jar -DgroupId=com.github.luxlang -DartifactId=lux-python -Dversion=0.6.3 -Dpackaging=jar
+&& mvn install:install-file -Dfile=target/program.jar -DgroupId=com.github.luxlang -DartifactId=lux-python -Dversion=0.7.0-SNAPSHOT -Dpackaging=jar
+
+cd ~/lux/lux-python/ && mvn deploy:deploy-file \
+-Durl=https://$NEXUS_USERNAME:$NEXUS_PASSWORD@oss.sonatype.org/content/repositories/snapshots/ \
+-Dfile=target/program.jar \
+-DgroupId=com.github.luxlang \
+-DartifactId=lux-python \
+-Dversion=0.7.0-SNAPSHOT \
+-Dpackaging=jar
```
diff --git a/lux-python/project.lux b/lux-python/project.lux
index 916dbd5a9..f69567703 100644
--- a/lux-python/project.lux
+++ b/lux-python/project.lux
@@ -1,5 +1,5 @@
[""
- ["identity" ["com.github.luxlang" "lux-python" "0.6.5"]
+ ["identity" ["com.github.luxlang" "lux-python" "0.7.0-SNAPSHOT"]
"description" "A Python compiler for Lux."
"info" ["url" "https://github.com/LuxLang/lux"
"scm" "https://github.com/LuxLang/lux.git"
@@ -15,8 +15,9 @@
"repositories" ["https://oss.sonatype.org/content/repositories/snapshots/"
"https://oss.sonatype.org/service/local/staging/deploy/maven2/"]
- "compiler" ["com.github.luxlang" "lux-jvm" "0.6.5" "jar"]
+ "lux" ["com.github.luxlang" "lux-jvm" "0.7.0-SNAPSHOT" "jar"]
"dependencies" [... ["com.github.luxlang" "stdlib" "0.6.5" "tar"]
- ["org.python" "jython-standalone" "2.7.2" "jar"]]
+ ["org.python" "jython-standalone" "2.7.2" "jar"]
+ ["com.github.luxlang" "lux-jvm-function" "0.6.5" "jar"]]
"program" "program"]]
diff --git a/lux-python/source/program.lux b/lux-python/source/program.lux
index 25a2131c5..d12ea355c 100644
--- a/lux-python/source/program.lux
+++ b/lux-python/source/program.lux
@@ -157,7 +157,7 @@
{try.#Success value}
(case (read value)
{try.#Success lux_value}
- (again (++ idx) (array.write! idx lux_value output))
+ (again (++ idx) (array.has! idx lux_value output))
failure
failure)
@@ -314,7 +314,7 @@
org/python/core/PyObject
(case (|> it
(as (Array Any))
- (array.read! (|> index' ffi.int_to_long (as Nat))))
+ (array.item (|> index' ffi.int_to_long (as Nat))))
{.#None}
(::super! [index'])
diff --git a/stdlib/source/library/lux/control/concurrency/atom.lux b/stdlib/source/library/lux/control/concurrency/atom.lux
index 08533b6a5..39207767c 100644
--- a/stdlib/source/library/lux/control/concurrency/atom.lux
+++ b/stdlib/source/library/lux/control/concurrency/atom.lux
@@ -44,7 +44,7 @@
(with_expansions [<jvm> (as_expected (java/util/concurrent/atomic/AtomicReference::new value))]
(for @.old <jvm>
@.jvm <jvm>
- (array.has! 0 value (array.empty 1))))))
+ (array.has! 0 (variance.write value) (array.empty 1))))))
(def: .public (read! atom)
(All (_ r w) (-> (Atom' r w) (IO r)))
@@ -63,12 +63,14 @@
(representation atom)))
@.jvm (ffi.of_boolean
(java/util/concurrent/atomic/AtomicReference::compareAndSet current new (representation atom)))
- (let [old (array.item 0 (representation atom))]
- (if (same? old current)
- (exec
- (array.has! 0 new (representation atom))
- true)
- false)))))
+ (if (|> (representation atom)
+ (array.item 0)
+ variance.read
+ (same? current))
+ (exec
+ (array.has! 0 (variance.write new) (representation atom))
+ true)
+ false))))
)
(def: .public (update! f atom)
diff --git a/stdlib/source/library/lux/tool/compiler/default/platform.lux b/stdlib/source/library/lux/tool/compiler/default/platform.lux
index 1facd15f6..9201b9cc2 100644
--- a/stdlib/source/library/lux/tool/compiler/default/platform.lux
+++ b/stdlib/source/library/lux/tool/compiler/default/platform.lux
@@ -115,10 +115,8 @@
(let [system (the #&file_system platform)
write_artifact! (is (-> [artifact.ID (Maybe Text) Binary] (Action Any))
(function (_ [artifact_id custom content])
- (with_expansions [<it> (cache/artifact.cache! system context @module artifact_id content)]
- (for @.old (as (Async (Try Any))
- <it>)
- <it>))))]
+ (is (Async (Try Any))
+ (cache/artifact.cache! system context @module artifact_id content))))]
(do [! ..monad]
[_ (is (Async (Try Any))
(cache/module.enable! async.monad system context @module))
@@ -135,15 +133,13 @@
(is (Action (List Any)))))
document (# async.monad in
(document.marked? key (the [archive.#module module.#document] entry)))]
- (with_expansions [<it> (|> [(|> entry
- (the archive.#module)
- (has module.#document document))
- (the archive.#registry entry)]
- (_.result (..writer format))
- (cache/module.cache! system context @module))]
- (for @.old (as (Async (Try Any))
- <it>)
- <it>)))))
+ (is (Async (Try Any))
+ (|> [(|> entry
+ (the archive.#module)
+ (has module.#document document))
+ (the archive.#registry entry)]
+ (_.result (..writer format))
+ (cache/module.cache! system context @module))))))
... TODO: Inline ASAP
(def: initialize_buffer!
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/python.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/python.lux
index f07d818d5..fa87792da 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/python.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/python.lux
@@ -9,7 +9,7 @@
["<[0]>" code {"+" Parser}]]]
[data
[collection
- ["[0]" array {"+" Array}]
+ ["[0]" array]
["[0]" dictionary]
["[0]" list]]]
["[0]" type
@@ -32,11 +32,13 @@
[<code>.any
(function (_ extension phase archive lengthC)
(<| analysis/type.with_var
- (function (_ [@var :var:]))
+ (function (_ [@read :read:]))
+ analysis/type.with_var
+ (function (_ [@write :write:]))
(do phase.monad
[lengthA (analysis/type.expecting Nat
(phase archive lengthC))
- _ (analysis/type.inference (type (Array :var:)))]
+ _ (analysis/type.inference (type (array.Array' :read: :write:)))]
(in {analysis.#Extension extension (list lengthA)}))))]))
(def: array::length
@@ -45,9 +47,11 @@
[<code>.any
(function (_ extension phase archive arrayC)
(<| analysis/type.with_var
- (function (_ [@var :var:]))
+ (function (_ [@read :read:]))
+ analysis/type.with_var
+ (function (_ [@write :write:]))
(do phase.monad
- [arrayA (analysis/type.expecting (type (Array :var:))
+ [arrayA (analysis/type.expecting (type (array.Array' :read: :write:))
(phase archive arrayC))
_ (analysis/type.inference Nat)]
(in {analysis.#Extension extension (list arrayA)}))))]))
@@ -58,13 +62,15 @@
[(<>.and <code>.any <code>.any)
(function (_ extension phase archive [indexC arrayC])
(<| analysis/type.with_var
- (function (_ [@var :var:]))
+ (function (_ [@read :read:]))
+ analysis/type.with_var
+ (function (_ [@write :write:]))
(do phase.monad
[indexA (analysis/type.expecting Nat
(phase archive indexC))
- arrayA (analysis/type.expecting (type (Array :var:))
+ arrayA (analysis/type.expecting (type (array.Array' :read: :write:))
(phase archive arrayC))
- _ (analysis/type.inference :var:)]
+ _ (analysis/type.inference :read:)]
(in {analysis.#Extension extension (list indexA arrayA)}))))]))
(def: array::write
@@ -73,15 +79,17 @@
[($_ <>.and <code>.any <code>.any <code>.any)
(function (_ extension phase archive [indexC valueC arrayC])
(<| analysis/type.with_var
- (function (_ [@var :var:]))
+ (function (_ [@read :read:]))
+ analysis/type.with_var
+ (function (_ [@write :write:]))
(do phase.monad
[indexA (analysis/type.expecting Nat
(phase archive indexC))
- valueA (analysis/type.expecting :var:
+ valueA (analysis/type.expecting :write:
(phase archive valueC))
- arrayA (analysis/type.expecting (type (Array :var:))
+ arrayA (analysis/type.expecting (type (array.Array' :read: :write:))
(phase archive arrayC))
- _ (analysis/type.inference (type (Array :var:)))]
+ _ (analysis/type.inference (type (array.Array' :read: :write:)))]
(in {analysis.#Extension extension (list indexA valueA arrayA)}))))]))
(def: array::delete
@@ -90,13 +98,15 @@
[($_ <>.and <code>.any <code>.any)
(function (_ extension phase archive [indexC arrayC])
(<| analysis/type.with_var
- (function (_ [@var :var:]))
+ (function (_ [@read :read:]))
+ analysis/type.with_var
+ (function (_ [@write :write:]))
(do phase.monad
[indexA (analysis/type.expecting Nat
(phase archive indexC))
- arrayA (analysis/type.expecting (type (Array :var:))
+ arrayA (analysis/type.expecting (type (array.Array' :read: :write:))
(phase archive arrayC))
- _ (analysis/type.inference (type (Array :var:)))]
+ _ (analysis/type.inference (type (array.Array' :read: :write:)))]
(in {analysis.#Extension extension (list indexA arrayA)}))))]))
(def: bundle::array
diff --git a/stdlib/source/library/lux/world/file.lux b/stdlib/source/library/lux/world/file.lux
index c0c76d6de..d04f8c052 100644
--- a/stdlib/source/library/lux/world/file.lux
+++ b/stdlib/source/library/lux/world/file.lux
@@ -1,6 +1,6 @@
(.`` (.`` (.using
[library
- [lux "*"
+ [lux {"-" open}
["@" target]
[abstract
["[0]" monad {"+" Monad do}]]
diff --git a/stdlib/source/test/lux/target/python.lux b/stdlib/source/test/lux/target/python.lux
index 1f53986c0..bddebfde0 100644
--- a/stdlib/source/test/lux/target/python.lux
+++ b/stdlib/source/test/lux/target/python.lux
@@ -22,7 +22,7 @@
["[0]" list ("[1]#[0]" functor)]]]
[macro
["[0]" code]]
- ["[0]" math
+ [math
["[0]" random {"+" Random} ("[1]#[0]" monad)]
[number
["n" nat]
@@ -118,7 +118,7 @@
[/.* f.* |>]
[/./ f./ |>]
[/.% f.mod |>]
- [/.** math.pow f.abs]
+ [/.** f.pow f.abs]
))
(~~ (template [</> <lux>]
[(_.cover [</>]
@@ -316,7 +316,7 @@
(expression (function.constant true)
(/.__import__/1 (/.string "math"))))
(_.cover [/.do]
- (expression (|>> (as Frac) (f.= (math.ceil float)))
+ (expression (|>> (as Frac) (f.= (f.ceil float)))
(|> (/.__import__/1 (/.string "math"))
(/.do "ceil" (list (/.float float))))))
(_.cover [/.is]
diff --git a/stdlib/source/unsafe/lux/data/collection/array.lux b/stdlib/source/unsafe/lux/data/collection/array.lux
index 0a44efcf8..7ad2f8a84 100644
--- a/stdlib/source/unsafe/lux/data/collection/array.lux
+++ b/stdlib/source/unsafe/lux/data/collection/array.lux
@@ -33,21 +33,21 @@
(`` (template: .public (empty <size>)
[((.is (.All (_ a) (.-> .Nat (..Array a)))
(.function (empty size)
- (.for (~~ (.static @.old))
- (.as_expected ("jvm anewarray" "(java.lang.Object )" size))
-
- (~~ (.static @.jvm))
- (|> (~~ (..jvm_int size))
- "jvm array new object"
- (.is (..Array <item_type>))
- .as_expected)
-
- (~~ (.static @.js)) ("js array new" size)
- (~~ (.static @.python)) ("python array new" size)
- (~~ (.static @.lua)) ("lua array new" size)
- (~~ (.static @.ruby)) ("ruby array new" size)
- (~~ (.static @.php)) ("php array new" size)
- (~~ (.static @.scheme)) ("scheme array new" size))))
+ (.as_expected
+ (.for (~~ (.static @.old))
+ ("jvm anewarray" "(java.lang.Object )" size)
+
+ (~~ (.static @.jvm))
+ (|> (~~ (..jvm_int size))
+ "jvm array new object"
+ (.is (..Array <item_type>)))
+
+ (~~ (.static @.js)) ("js array new" size)
+ (~~ (.static @.python)) ("python array new" size)
+ (~~ (.static @.lua)) ("lua array new" size)
+ (~~ (.static @.ruby)) ("ruby array new" size)
+ (~~ (.static @.php)) ("php array new" size)
+ (~~ (.static @.scheme)) ("scheme array new" size)))))
<size>)]))
(`` (template: .public (size <array>)