Fixes for the pure-Lux JVM compiler machinery. [Part 13 / Done!]

12 files changed, 235 insertions, 232 deletions

diff --git a/stdlib/source/library/lux/math/number/i32.lux b/stdlib/source/library/lux/math/number/i32.lux
index c08f261b1..e8967c412 100644
--- a/stdlib/source/library/lux/math/number/i32.lux
+++ b/stdlib/source/library/lux/math/number/i32.lux
@@ -1,16 +1,18 @@
 (.using
-  [library
-   [lux {"-" i64}
-    [type {"+" :by_example}]
-    [abstract
-     [equivalence {"+" Equivalence}]]
-    [control
-     ["[0]" maybe]]]]
-  [//
-   ["[0]" i64 {"+" Sub}]])
+ [library
+  [lux {"-" i64}
+   [type {"+" :by_example}]
+   [abstract
+    [equivalence {"+" Equivalence}]]
+   [control
+    ["[0]" maybe]]]]
+ [//
+  ["[0]" i64 {"+" Sub}]])
 
 (def: sub
-  (maybe.trusted (i64.sub 32)))
+  ... TODO: Stop needing this coercion.
+  (:as (Sub (I64 (Primitive "#I32")))
+       (maybe.trusted (i64.sub 32))))
 
 (def: .public I32
   Type
diff --git a/stdlib/source/library/lux/target/jvm/bytecode.lux b/stdlib/source/library/lux/target/jvm/bytecode.lux
index d7a29db73..17f2dd229 100644
--- a/stdlib/source/library/lux/target/jvm/bytecode.lux
+++ b/stdlib/source/library/lux/target/jvm/bytecode.lux
@@ -750,11 +750,10 @@
   (do [! try.monad]
     [jump (# ! each //signed.value
              (/address.jump @from @to))]
-    (let [big? (n.> (//unsigned.value //unsigned.maximum/2)
-                    (.nat (i.* (if (i.< +0 jump)
-                                 -1
-                                 +1)
-                               jump)))]
+    (let [big? (or (i.> (//signed.value //signed.maximum/2)
+                        jump)
+                   (i.< (//signed.value //signed.minimum/2)
+                        jump))]
       (if big?
         (# ! each (|>> {.#Left}) (//signed.s4 jump))
         (# ! each (|>> {.#Right}) (//signed.s2 jump))))))
diff --git a/stdlib/source/library/lux/target/jvm/encoding/signed.lux b/stdlib/source/library/lux/target/jvm/encoding/signed.lux
index f4f664878..d33321b60 100644
--- a/stdlib/source/library/lux/target/jvm/encoding/signed.lux
+++ b/stdlib/source/library/lux/target/jvm/encoding/signed.lux
@@ -47,7 +47,7 @@
      ["Value" (%.int value)]
      ["Scope (in bytes)" (%.nat scope)]))
 
-  (template [<bytes> <name> <size> <constructor> <maximum> <+> <->]
+  (template [<bytes> <name> <size> <constructor> <maximum> <minimum> <+> <->]
     [(with_expansions [<raw> (template.symbol [<name> "'"])]
        (abstract: <raw> Any)
        (type: .public <name> (Signed <raw>)))
@@ -57,6 +57,11 @@
      (def: .public <maximum>
        <name>
        (|> <bytes> (n.* i64.bits_per_byte) -- i64.mask :abstraction))
+
+     (def: .public <minimum>
+       <name>
+       (let [it (:representation <maximum>)]
+         (:abstraction (-- (i.- it +0)))))
      
      (def: .public <constructor>
        (-> Int (Try <name>))
@@ -81,9 +86,9 @@
        [<-> i.-]
        )]
 
-    [1 S1 bytes/1 s1 maximum/1 +/1 -/1]
-    [2 S2 bytes/2 s2 maximum/2 +/2 -/2]
-    [4 S4 bytes/4 s4 maximum/4 +/4 -/4]
+    [1 S1 bytes/1 s1 maximum/1 minimum/1 +/1 -/1]
+    [2 S2 bytes/2 s2 maximum/2 minimum/2 +/2 -/2]
+    [4 S4 bytes/4 s4 maximum/4 minimum/4 +/4 -/4]
     )
 
   (template [<name> <from> <to>]
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
index d4f217dd0..657096c10 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis.lux
@@ -17,7 +17,7 @@
     ["[0]" location]]]]
  ["[0]" / "_"
   ["[1][0]" simple]
-  ["[1][0]" structure]
+  ["[1][0]" complex]
   ["[1][0]" reference]
   ["[1][0]" case]
   ["[1][0]" function]
@@ -60,22 +60,22 @@
                          values)})
     (case values
       {.#Item value {.#End}}
-      (/structure.tagged_sum compile tag archive value)
+      (/complex.variant compile tag archive value)
 
       _
-      (/structure.tagged_sum compile tag archive (` [(~+ values)])))
+      (/complex.variant compile tag archive (` [(~+ values)])))
 
     (^ {.#Variant (list& [_ {.#Nat lefts}] [_ {.#Bit right?}]
                          values)})
     (case values
       {.#Item value {.#End}}
-      (/structure.sum compile lefts right? archive value)
+      (/complex.sum compile lefts right? archive value)
 
       _
-      (/structure.sum compile lefts right? archive (` [(~+ values)])))
+      (/complex.sum compile lefts right? archive (` [(~+ values)])))
 
     (^ {.#Tuple elems})
-    (/structure.record archive compile elems)
+    (/complex.record compile archive elems)
 
     _
     (else code')))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
index 2b99be974..3eab189d4 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/case.lux
@@ -25,7 +25,7 @@
   ["[1][0]" coverage {"+" Coverage}]
   ["/[1]" // "_"
    ["[1][0]" scope]
-   ["[1][0]" structure]
+   ["[1][0]" complex]
    ["/[1]" // "_"
     ["[1][0]" extension]
     [//
@@ -247,11 +247,11 @@
     [location {.#Tuple sub_patterns}]
     (/.with_location location
       (do [! ///.monad]
-        [record (//structure.normal sub_patterns)
+        [record (//complex.normal sub_patterns)
          record_size,members,recordT (: (Operation (Maybe [Nat (List Code) Type]))
                                         (.case record
                                           {.#Some record}
-                                          (//structure.order true record)
+                                          (//complex.order true record)
 
                                           {.#None}
                                           (in {.#None})))]
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/complex.lux
index cdf65a6ad..678a626da 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/structure.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/analysis/complex.lux
@@ -35,10 +35,14 @@
      ["[1][0]" type]
      ["[1][0]" inference]]
     [///
-     ["[1]" phase]
+     ["[1]" phase ("[1]#[0]" monad)]
      [meta
       [archive {"+" Archive}]]]]]])
 
+(exception: .public (not_a_quantified_type [type Type])
+  (exception.report
+   ["Type" (%.type type)]))
+
 (template [<name>]
   [(exception: .public (<name> [type Type
                                 members (List Code)])
@@ -50,36 +54,30 @@
   [cannot_analyse_tuple]
   )
 
-(exception: .public (not_a_quantified_type [type Type])
-  (exception.report
-   ["Type" (%.type type)]))
-
 (template [<name>]
   [(exception: .public (<name> [type Type
-                                tag Tag
+                                lefts Nat
+                                right? Bit
                                 code Code])
      (exception.report
       ["Type" (%.type type)]
-      ["Tag" (%.nat tag)]
+      ["Lefts" (%.nat lefts)]
+      ["Right?" (%.bit right?)]
       ["Expression" (%.code code)]))]
 
   [invalid_variant_type]
   [cannot_analyse_variant]
-  [cannot_infer_numeric_tag]
+  [cannot_infer_sum]
   )
 
-(template [<name>]
-  [(exception: .public (<name> [key Symbol
-                                record (List [Symbol Code])])
-     (exception.report
-      ["Slot" (%.code (code.symbol key))]
-      ["Record" (%.code (code.tuple (|> record
-                                        (list#each (function (_ [keyI valC])
-                                                     (list (code.symbol keyI) valC)))
-                                        list#conjoint)))]))]
-
-  [cannot_repeat_slot]
-  )
+(exception: .public (cannot_repeat_slot [key Symbol
+                                         record (List [Symbol Code])])
+  (exception.report
+   ["Slot" (%.code (code.symbol key))]
+   ["Record" (%.code (code.tuple (|> record
+                                     (list#each (function (_ [keyI valC])
+                                                  (list (code.symbol keyI) valC)))
+                                     list#conjoint)))]))
 
 (exception: .public (slot_does_not_belong_to_record [key Symbol
                                                      type Type])
@@ -108,7 +106,7 @@
       (do [! ///.monad]
         [expectedT (///extension.lifted meta.expected_type)
          expectedT' (/type.check (check.clean expectedT))]
-        (/.with_stack ..cannot_analyse_variant [expectedT' tag valueC]
+        (/.with_stack ..cannot_analyse_variant [expectedT' lefts right? valueC]
           (case expectedT
             {.#Sum _}
             (|> (analyse archive valueC)
@@ -134,13 +132,13 @@
                 ... This is because there is no way of knowing how many
                 ... cases the inferred sum type would have.
                 _
-                (/.except ..cannot_infer_numeric_tag [expectedT tag valueC])))
+                (/.except ..cannot_infer_sum [expectedT lefts right? valueC])))
 
             (^template [<tag> <instancer>]
               [{<tag> _}
                (do !
-                 [[instance_id instanceT] (/type.check <instancer>)]
-                 (<| (/type.expecting (maybe.trusted (type.applied (list instanceT) expectedT)))
+                 [[@instance :instance:] (/type.check <instancer>)]
+                 (<| (/type.expecting (maybe.trusted (type.applied (list :instance:) expectedT)))
                      (again valueC)))])
             ([.#UnivQ check.existential]
              [.#ExQ check.var])
@@ -156,7 +154,7 @@
                       (again valueC))
 
                   _
-                  (/.except ..invalid_variant_type [expectedT tag valueC])))
+                  (/.except ..invalid_variant_type [expectedT lefts right? valueC])))
 
               _
               (case (type.applied (list inputT) funT)
@@ -165,56 +163,72 @@
                     (again valueC))
 
                 {.#None}
-                (/.except ..not_a_quantified_type funT)))
+                (/.except ..not_a_quantified_type [funT])))
             
             _
-            (/.except ..invalid_variant_type [expectedT tag valueC])))))))
+            (/.except ..invalid_variant_type [expectedT lefts right? valueC])))))))
 
-(def: (typed_product archive analyse members)
-  (-> Archive Phase (List Code) (Operation Analysis))
+(def: .public (variant analyse tag archive valueC)
+  (-> Phase Symbol Phase)
   (do [! ///.monad]
-    [expectedT (///extension.lifted meta.expected_type)
-     membersA+ (: (Operation (List Analysis))
-                  (loop [membersT+ (type.flat_tuple expectedT)
-                         membersC+ members]
-                    (case [membersT+ membersC+]
-                      [{.#Item memberT {.#End}} {.#Item memberC {.#End}}]
-                      (do !
-                        [memberA (<| (/type.expecting memberT)
-                                     (analyse archive memberC))]
-                        (in (list memberA)))
-                      
-                      [{.#Item memberT {.#End}} _]
-                      (<| (/type.expecting memberT)
-                          (# ! each (|>> list) (analyse archive (code.tuple membersC+))))
-                      
-                      [_ {.#Item memberC {.#End}}]
-                      (<| (/type.expecting (type.tuple membersT+))
-                          (# ! each (|>> list) (analyse archive memberC)))
-                      
-                      [{.#Item memberT membersT+'} {.#Item memberC membersC+'}]
-                      (do !
-                        [memberA (<| (/type.expecting memberT)
-                                     (analyse archive memberC))
-                         memberA+ (again membersT+' membersC+')]
-                        (in {.#Item memberA memberA+}))
-                      
-                      _
-                      (/.except ..cannot_analyse_tuple [expectedT members]))))]
-    (in (/.tuple membersA+))))
-
-(def: .public (product archive analyse membersC)
-  (-> Archive Phase (List Code) (Operation Analysis))
+    [tag (///extension.lifted (meta.normal tag))
+     [idx group variantT] (///extension.lifted (meta.tag tag))
+     .let [case_size (list.size group)
+           [lefts right?] (/complex.choice case_size idx)]
+     expectedT (///extension.lifted meta.expected_type)]
+    (case expectedT
+      {.#Var _}
+      (do !
+        [inferenceT (/inference.variant lefts right? variantT)
+         [inferredT valueA+] (/inference.general archive analyse inferenceT (list valueC))]
+        (in (/.variant [lefts right? (|> valueA+ list.head maybe.trusted)])))
+
+      _
+      (..sum analyse lefts right? archive valueC))))
+
+(def: (typed_product analyse expectedT archive members)
+  (-> Phase Type Archive (List Code) (Operation Analysis))
+  (<| (let [! ///.monad])
+      (# ! each (|>> /.tuple))
+      (: (Operation (List Analysis)))
+      (loop [membersT+ (type.flat_tuple expectedT)
+             membersC+ members]
+        (case [membersT+ membersC+]
+          [{.#Item memberT {.#End}} {.#Item memberC {.#End}}]
+          (<| (# ! each (|>> list))
+              (/type.expecting memberT)
+              (analyse archive memberC))
+          
+          [{.#Item memberT {.#End}} _]
+          (<| (/type.expecting memberT)
+              (# ! each (|>> list) (analyse archive (code.tuple membersC+))))
+          
+          [_ {.#Item memberC {.#End}}]
+          (<| (/type.expecting (type.tuple membersT+))
+              (# ! each (|>> list) (analyse archive memberC)))
+          
+          [{.#Item memberT membersT+'} {.#Item memberC membersC+'}]
+          (do !
+            [memberA (<| (/type.expecting memberT)
+                         (analyse archive memberC))
+             memberA+ (again membersT+' membersC+')]
+            (in {.#Item memberA memberA+}))
+          
+          _
+          (/.except ..cannot_analyse_tuple [expectedT members])))))
+
+(def: .public (product analyse archive membersC)
+  (-> Phase Archive (List Code) (Operation Analysis))
   (do [! ///.monad]
     [expectedT (///extension.lifted meta.expected_type)]
     (/.with_stack ..cannot_analyse_tuple [expectedT membersC]
       (case expectedT
         {.#Product _}
-        (..typed_product archive analyse membersC)
+        (..typed_product analyse expectedT archive membersC)
 
         {.#Named name unnamedT}
         (<| (/type.expecting unnamedT)
-            (product archive analyse membersC))
+            (product analyse archive membersC))
 
         {.#Var id}
         (do !
@@ -222,10 +236,10 @@
           (case ?expectedT'
             {.#Some expectedT'}
             (<| (/type.expecting expectedT')
-                (product archive analyse membersC))
+                (product analyse archive membersC))
 
             _
-            ... Must do inference...
+            ... Must infer...
             (do !
               [membersTA (monad.each ! (|>> (analyse archive) /type.inferring)
                                      membersC)
@@ -236,9 +250,9 @@
         (^template [<tag> <instancer>]
           [{<tag> _}
            (do !
-             [[instance_id instanceT] (/type.check <instancer>)]
-             (<| (/type.expecting (maybe.trusted (type.applied (list instanceT) expectedT)))
-                 (product archive analyse membersC)))])
+             [[@instance :instance:] (/type.check <instancer>)]
+             (<| (/type.expecting (maybe.trusted (type.applied (list :instance:) expectedT)))
+                 (product analyse archive membersC)))])
         ([.#UnivQ check.existential]
          [.#ExQ check.var])
 
@@ -250,7 +264,7 @@
             (case ?funT'
               {.#Some funT'}
               (<| (/type.expecting {.#Apply inputT funT'})
-                  (product archive analyse membersC))
+                  (product analyse archive membersC))
 
               _
               (/.except ..invalid_tuple_type [expectedT membersC])))
@@ -259,7 +273,7 @@
           (case (type.applied (list inputT) funT)
             {.#Some outputT}
             (<| (/type.expecting outputT)
-                (product archive analyse membersC))
+                (product analyse archive membersC))
 
             {.#None}
             (/.except ..not_a_quantified_type funT)))
@@ -268,24 +282,6 @@
         (/.except ..invalid_tuple_type [expectedT membersC])
         ))))
 
-(def: .public (tagged_sum analyse tag archive valueC)
-  (-> Phase Symbol Phase)
-  (do [! ///.monad]
-    [tag (///extension.lifted (meta.normal tag))
-     [idx group variantT] (///extension.lifted (meta.tag tag))
-     .let [case_size (list.size group)
-           [lefts right?] (/complex.choice case_size idx)]
-     expectedT (///extension.lifted meta.expected_type)]
-    (case expectedT
-      {.#Var _}
-      (do !
-        [inferenceT (/inference.variant lefts right? variantT)
-         [inferredT valueA+] (/inference.general archive analyse inferenceT (list valueC))]
-        (in (/.variant [lefts right? (|> valueA+ list.head maybe.trusted)])))
-
-      _
-      (..sum analyse lefts right? archive valueC))))
-
 ... There cannot be any ambiguity or improper syntax when analysing
 ... records, so they must be normalized for further analysis.
 ... Normalization just means that all the tags get resolved to their
@@ -302,10 +298,10 @@
         (again tail {.#Item [slotH valueH] output}))
 
       {.#End}
-      (# ///.monad in {.#Some output})
+      (///#in {.#Some output})
 
       _
-      (# ///.monad in {.#None}))))
+      (///#in {.#None}))))
 
 (def: (local_binding? name)
   (-> Text (Meta Bit))
@@ -361,25 +357,25 @@
   (case record
     ... empty_record = empty_tuple = unit/any = []
     {.#End}
-    (# ///.monad in {.#Some [0 (list) Any]})
+    (///#in {.#Some [0 (list) .Any]})
 
     {.#Item [head_k head_v] _}
     (case head_k
       ["" head_k']
       (if pattern_matching?
-        (# ///.monad in {.#None})
+        (///#in {.#None})
         (do ///.monad
           [local_binding? (///extension.lifted
-                           (local_binding? head_k'))]
+                           (..local_binding? head_k'))]
           (if local_binding?
-            (order' head_k record)
-            (in {.#None}))))
+            (in {.#None})
+            (order' head_k record))))
       
       _
       (order' head_k record))))
 
-(def: .public (record archive analyse members)
-  (-> Archive Phase (List Code) (Operation Analysis))
+(def: .public (record analyse archive members)
+  (-> Phase Archive (List Code) (Operation Analysis))
   (case members
     (^ (list))
     //simple.unit
@@ -395,24 +391,24 @@
         {try.#Success [_ slot_set recordT]}
         (case (list.size slot_set)
           1 (analyse archive singletonC)
-          _ (..product archive analyse members))
+          _ (..product analyse archive members))
 
         _
-        (..product archive analyse members)))
+        (..product analyse archive members)))
 
     _
     (do [! ///.monad]
       [?members (normal members)]
       (case ?members
         {.#None}
-        (..product archive analyse members)
+        (..product analyse archive members)
 
         {.#Some slots}
         (do !
           [record_size,membersC,recordT (..order false slots)]
           (case record_size,membersC,recordT
             {.#None}
-            (..product archive analyse members)
+            (..product analyse archive members)
 
             {.#Some [record_size membersC recordT]}
             (do !
@@ -425,4 +421,4 @@
                   (in (/.tuple membersA)))
 
                 _
-                (..product archive analyse membersC)))))))))
+                (..product analyse archive membersC)))))))))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
index 2b146414f..4d6c7e712 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/jvm.lux
@@ -2180,19 +2180,18 @@
                   [[_ parameterT] check.existential]
                   (in [parameterJ parameterT])))))
 
+(def: (matched? [sub sub_method subJT] [super super_method superJT])
+  (-> [(Type Class) Text (Type Method)] [(Type Class) Text (Type Method)] Bit)
+  (and (# descriptor.equivalence = (jvm.descriptor super) (jvm.descriptor sub))
+       (text#= super_method sub_method)
+       (jvm#= superJT subJT)))
+
 (def: (mismatched_methods super_set sub_set)
   (-> (List [(Type Class) Text (Type Method)])
       (List [(Type Class) Text (Type Method)])
       (List [(Type Class) Text (Type Method)]))
-  (list.only (function (_ [sub sub_name subJT])
-               (|> super_set
-                   (list.only (function (_ [super super_name superJT])
-                                (and (jvm#= super sub)
-                                     (text#= super_name sub_name)
-                                     (jvm#= superJT subJT))))
-                   list.size
-                   (n.= 1)
-                   not))
+  (list.only (function (_ sub)
+               (not (list.any? (matched? sub) super_set)))
              sub_set))
 
 (exception: .public (class_parameter_mismatch [name Text
@@ -2254,7 +2253,7 @@
                                    methods)
      .let [missing_abstract_methods (mismatched_methods overriden_methods required_abstract_methods)
            invalid_overriden_methods (mismatched_methods available_methods overriden_methods)]
-     _ (phase.assertion ..missing_abstract_methods [required_abstract_methods missing_abstract_methods]
+     _ (phase.assertion ..missing_abstract_methods [required_abstract_methods overriden_methods]
                         (list.empty? missing_abstract_methods))
      _ (phase.assertion ..invalid_overriden_methods [available_methods invalid_overriden_methods]
                         (list.empty? invalid_overriden_methods))]
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lua.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lua.lux
index e6953ac59..7e286955e 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lua.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/extension/analysis/lua.lux
@@ -1,32 +1,30 @@
 (.using
-  [library
-   [lux "*"
-    ["[0]" ffi]
-    [abstract
-     ["[0]" monad {"+" do}]]
-    [control
-     ["<>" parser
-      ["<[0]>" code {"+" Parser}]]]
-    [data
-     [collection
-      ["[0]" array {"+" Array}]
-      ["[0]" dictionary]
-      ["[0]" list]]]
-    ["[0]" type
-     ["[0]" check]]
-    ["@" target
-     ["_" lua]]]]
+ [library
+  [lux "*"
+   ["[0]" ffi]
+   [abstract
+    ["[0]" monad {"+" do}]]
+   [control
+    ["<>" parser
+     ["<[0]>" code {"+" Parser}]]]
+   [data
+    [collection
+     ["[0]" array {"+" Array}]
+     ["[0]" dictionary]
+     ["[0]" list]]]
+   ["[0]" type
+    ["[0]" check]]
+   ["@" target
+    ["_" lua]]]]
+ [//
+  ["/" lux {"+" custom}]
   [//
-   ["/" lux {"+" custom}]
-   [//
-    ["[0]" bundle]
-    [//
-     ["[0]" analysis "_"
-      ["[1]/[0]" type]]
-     [//
-      ["[0]" analysis {"+" Analysis Operation Phase Handler Bundle}]
-      [///
-       ["[0]" phase]]]]]])
+   ["[0]" bundle]
+   [///
+    ["[0]" analysis {"+" Analysis Operation Phase Handler Bundle}
+     ["[1]/[0]" type]]
+    [///
+     ["[0]" phase]]]]])
 
 (def: Nil
   (for [@.lua ffi.Nil]
@@ -46,10 +44,10 @@
    [<code>.any
     (function (_ extension phase archive lengthC)
       (do phase.monad
-        [lengthA (analysis/type.with_type Nat
-                   (phase archive lengthC))
-         [var_id varT] (analysis/type.with_env check.var)
-         _ (analysis/type.infer (type (Array varT)))]
+        [lengthA (analysis/type.expecting Nat
+                                          (phase archive lengthC))
+         [var_id varT] (analysis/type.check check.var)
+         _ (analysis/type.inference (type (Array varT)))]
         (in {analysis.#Extension extension (list lengthA)})))]))
 
 (def: array::length
@@ -58,10 +56,10 @@
    [<code>.any
     (function (_ extension phase archive arrayC)
       (do phase.monad
-        [[var_id varT] (analysis/type.with_env check.var)
-         arrayA (analysis/type.with_type (type (Array varT))
-                  (phase archive arrayC))
-         _ (analysis/type.infer Nat)]
+        [[var_id varT] (analysis/type.check check.var)
+         arrayA (analysis/type.expecting (type (Array varT))
+                                         (phase archive arrayC))
+         _ (analysis/type.inference Nat)]
         (in {analysis.#Extension extension (list arrayA)})))]))
 
 (def: array::read
@@ -70,12 +68,12 @@
    [(<>.and <code>.any <code>.any)
     (function (_ extension phase archive [indexC arrayC])
       (do phase.monad
-        [indexA (analysis/type.with_type Nat
-                  (phase archive indexC))
-         [var_id varT] (analysis/type.with_env check.var)
-         arrayA (analysis/type.with_type (type (Array varT))
-                  (phase archive arrayC))
-         _ (analysis/type.infer varT)]
+        [indexA (analysis/type.expecting Nat
+                                         (phase archive indexC))
+         [var_id varT] (analysis/type.check check.var)
+         arrayA (analysis/type.expecting (type (Array varT))
+                                         (phase archive arrayC))
+         _ (analysis/type.inference varT)]
         (in {analysis.#Extension extension (list indexA arrayA)})))]))
 
 (def: array::write
@@ -84,14 +82,14 @@
    [($_ <>.and <code>.any <code>.any <code>.any)
     (function (_ extension phase archive [indexC valueC arrayC])
       (do phase.monad
-        [indexA (analysis/type.with_type Nat
-                  (phase archive indexC))
-         [var_id varT] (analysis/type.with_env check.var)
-         valueA (analysis/type.with_type varT
-                  (phase archive valueC))
-         arrayA (analysis/type.with_type (type (Array varT))
-                  (phase archive arrayC))
-         _ (analysis/type.infer (type (Array varT)))]
+        [indexA (analysis/type.expecting Nat
+                                         (phase archive indexC))
+         [var_id varT] (analysis/type.check check.var)
+         valueA (analysis/type.expecting varT
+                                         (phase archive valueC))
+         arrayA (analysis/type.expecting (type (Array varT))
+                                         (phase archive arrayC))
+         _ (analysis/type.inference (type (Array varT)))]
         (in {analysis.#Extension extension (list indexA valueA arrayA)})))]))
 
 (def: array::delete
@@ -100,12 +98,12 @@
    [($_ <>.and <code>.any <code>.any)
     (function (_ extension phase archive [indexC arrayC])
       (do phase.monad
-        [indexA (analysis/type.with_type Nat
-                  (phase archive indexC))
-         [var_id varT] (analysis/type.with_env check.var)
-         arrayA (analysis/type.with_type (type (Array varT))
-                  (phase archive arrayC))
-         _ (analysis/type.infer (type (Array varT)))]
+        [indexA (analysis/type.expecting Nat
+                                         (phase archive indexC))
+         [var_id varT] (analysis/type.check check.var)
+         arrayA (analysis/type.expecting (type (Array varT))
+                                         (phase archive arrayC))
+         _ (analysis/type.inference (type (Array varT)))]
         (in {analysis.#Extension extension (list indexA arrayA)})))]))
 
 (def: bundle::array
@@ -125,9 +123,9 @@
    [($_ <>.and <code>.text <code>.any)
     (function (_ extension phase archive [fieldC objectC])
       (do phase.monad
-        [objectA (analysis/type.with_type ..Object
-                   (phase archive objectC))
-         _ (analysis/type.infer .Any)]
+        [objectA (analysis/type.expecting ..Object
+                                          (phase archive objectC))
+         _ (analysis/type.inference .Any)]
         (in {analysis.#Extension extension (list (analysis.text fieldC)
                                                  objectA)})))]))
 
@@ -137,10 +135,10 @@
    [($_ <>.and <code>.text <code>.any (<>.some <code>.any))
     (function (_ extension phase archive [methodC objectC inputsC])
       (do [! phase.monad]
-        [objectA (analysis/type.with_type ..Object
-                   (phase archive objectC))
-         inputsA (monad.each ! (|>> (phase archive) (analysis/type.with_type Any)) inputsC)
-         _ (analysis/type.infer .Any)]
+        [objectA (analysis/type.expecting ..Object
+                                          (phase archive objectC))
+         inputsA (monad.each ! (|>> (phase archive) (analysis/type.expecting Any)) inputsC)
+         _ (analysis/type.inference .Any)]
         (in {analysis.#Extension extension (list& (analysis.text methodC)
                                                   objectA
                                                   inputsA)})))]))
@@ -162,9 +160,9 @@
       [<code>.any
        (function (_ extension phase archive inputC)
          (do [! phase.monad]
-           [inputA (analysis/type.with_type (type <fromT>)
-                     (phase archive inputC))
-            _ (analysis/type.infer (type <toT>))]
+           [inputA (analysis/type.expecting (type <fromT>)
+                                            (phase archive inputC))
+            _ (analysis/type.inference (type <toT>))]
            (in {analysis.#Extension extension (list inputA)})))]))]
 
   [utf8::encode Text (array.Array (I64 Any))]
@@ -185,7 +183,7 @@
    [<code>.text
     (function (_ extension phase archive name)
       (do phase.monad
-        [_ (analysis/type.infer Any)]
+        [_ (analysis/type.inference Any)]
         (in {analysis.#Extension extension (list (analysis.text name))})))]))
 
 (def: lua::apply
@@ -194,10 +192,10 @@
    [($_ <>.and <code>.any (<>.some <code>.any))
     (function (_ extension phase archive [abstractionC inputsC])
       (do [! phase.monad]
-        [abstractionA (analysis/type.with_type ..Function
-                        (phase archive abstractionC))
-         inputsA (monad.each ! (|>> (phase archive) (analysis/type.with_type Any)) inputsC)
-         _ (analysis/type.infer Any)]
+        [abstractionA (analysis/type.expecting ..Function
+                                               (phase archive abstractionC))
+         inputsA (monad.each ! (|>> (phase archive) (analysis/type.expecting Any)) inputsC)
+         _ (analysis/type.inference Any)]
         (in {analysis.#Extension extension (list& abstractionA inputsA)})))]))
 
 (def: lua::power
@@ -206,11 +204,11 @@
    [($_ <>.and <code>.any <code>.any)
     (function (_ extension phase archive [powerC baseC])
       (do [! phase.monad]
-        [powerA (analysis/type.with_type Frac
-                  (phase archive powerC))
-         baseA (analysis/type.with_type Frac
-                 (phase archive baseC))
-         _ (analysis/type.infer Frac)]
+        [powerA (analysis/type.expecting Frac
+                                         (phase archive powerC))
+         baseA (analysis/type.expecting Frac
+                                        (phase archive baseC))
+         _ (analysis/type.inference Frac)]
         (in {analysis.#Extension extension (list powerA baseA)})))]))
 
 (def: lua::import
@@ -219,7 +217,7 @@
    [<code>.text
     (function (_ extension phase archive name)
       (do phase.monad
-        [_ (analysis/type.infer ..Object)]
+        [_ (analysis/type.inference ..Object)]
         (in {analysis.#Extension extension (list (analysis.text name))})))]))
 
 (def: lua::function
@@ -229,9 +227,9 @@
     (function (_ extension phase archive [arity abstractionC])
       (do phase.monad
         [.let [inputT (type.tuple (list.repeated arity Any))]
-         abstractionA (analysis/type.with_type (-> inputT Any)
-                        (phase archive abstractionC))
-         _ (analysis/type.infer ..Function)]
+         abstractionA (analysis/type.expecting (-> inputT Any)
+                                               (phase archive abstractionC))
+         _ (analysis/type.inference ..Function)]
         (in {analysis.#Extension extension (list (analysis.nat arity)
                                                  abstractionA)})))]))
 
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux
index b5899731b..e2ed832c1 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/function.lux
@@ -20,20 +20,22 @@
   ["/[1]" // "_"
    ["[1][0]" reference]
    ["//[1]" /// "_"
-    [analysis {"+" Abstraction Application Analysis}]
+    [analysis {"+" Abstraction Reification Analysis}]
     [synthesis {"+" Synthesis}]
-    ["[1][0]" generation {"+" Context}]
+    ["[1][0]" generation]
     ["//[1]" /// "_"
      [arity {"+" Arity}]
      ["[1][0]" phase ("[1]#[0]" monad)]
      [meta
       [archive
-       ["[0]" dependency]]]
+       ["[0]" unit]]
+      ["[0]" cache "_"
+       ["[1]" artifact]]]
      [reference
       [variable {"+" Register Variable}]]]]]])
 
 (def: .public (apply expression archive [functionS argsS+])
-  (Generator (Application Synthesis))
+  (Generator (Reification Synthesis))
   (do [! ///////phase.monad]
     [functionO (expression archive functionS)
      argsO+ (monad.each ! (expression archive) argsS+)]
@@ -63,13 +65,13 @@
   (|>> ++ //case.register))
 
 (def: (@scope function_name)
-  (-> Context Label)
+  (-> unit.ID Label)
   (_.label (format (///reference.artifact function_name) "_scope")))
 
 (def: .public (function statement expression archive [environment arity bodyS])
   (-> Phase! (Generator (Abstraction Synthesis)))
   (do [! ///////phase.monad]
-    [dependencies (dependency.dependencies archive bodyS)
+    [dependencies (cache.dependencies archive bodyS)
      [function_name body!] (/////generation.with_new_context archive dependencies
                              (do !
                                [@scope (# ! each ..@scope
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/loop.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/loop.lux
index 06135b240..59d88e612 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/loop.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/loop.lux
@@ -26,8 +26,9 @@
     ["//[1]" /// "_"
      ["[1][0]" phase]
      [meta
-      [archive {"+" Archive}
-       ["[0]" dependency]]]
+      [archive {"+" Archive}]
+      ["[0]" cache "_"
+       ["[1]" artifact]]]
      [reference
       [variable {"+" Register}]]]]]])
 
@@ -82,7 +83,7 @@
     ... true loop
     _
     (do [! ///////phase.monad]
-      [dependencies (dependency.dependencies archive bodyS)
+      [dependencies (cache.dependencies archive bodyS)
        [[artifact_module artifact_id] [initsO+ scope!]] (/////generation.with_new_context archive dependencies
                                                           (scope! statement expression archive true [start initsS+ bodyS]))
        .let [@loop (_.var (///reference.artifact [artifact_module artifact_id]))
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
index 40525dd00..794bc1fd7 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/runtime.lux
@@ -36,7 +36,8 @@
      [variable {"+" Register}]]
     [meta
      [archive {"+" Output Archive}
-      ["[0]" artifact {"+" Registry}]]]]]])
+      ["[0]" registry {"+" Registry}]
+      ["[0]" unit]]]]]])
 
 (template [<name> <base>]
   [(type: .public <name>
@@ -425,8 +426,8 @@
   (do ///////phase.monad
     [_ (/////generation.execute! ..runtime)
      _ (/////generation.save! ..module_id {.#None} ..runtime)]
-    (in [(|> artifact.empty
-             (artifact.resource true artifact.no_dependencies)
+    (in [(|> registry.empty
+             (registry.resource true unit.none)
              product.right)
          (sequence.sequence [..module_id
                              {.#None}
diff --git a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux
index 97784804e..80028d75e 100644
--- a/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux
+++ b/stdlib/source/library/lux/tool/compiler/language/lux/phase/generation/lua/structure.lux
@@ -11,7 +11,7 @@
   ["///[1]" //// "_"
    ["[1][0]" synthesis {"+" Synthesis}]
    [analysis
-    [composite {"+" Variant Tuple}]]
+    [complex {"+" Variant Tuple}]]
    ["//[1]" /// "_"
     ["[1][0]" phase ("[1]#[0]" monad)]]]])