(.module:
  [library
   [lux {"-" Definition Type Label}
    [ffi {"+" import:}]
    [abstract
     monad]
    [control
     ["<>" parser
      ["<[0]>" code]]]
    [data
     [binary {"+" Binary}]
     [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)

(import: org/objectweb/asm/ClassWriter)

(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_identifier
                   none <code>.local_identifier
                   ++ <code>.local_identifier
                   options (<code>.tuple (<>.many <code>.local_identifier))])
  (let [g!type (code.local_identifier type)
        g!none (code.local_identifier none)
        g!tags+ (list#each code.local_tag options)
        g!_left (code.local_identifier "_left")
        g!_right (code.local_identifier "_right")
        g!options+ (list#each (function (_ option)
                                (` (def: .public (~ (code.local_identifier option))
                                     (~ g!type)
                                     (|> (~ g!none)
                                         (with@ (~ (code.local_tag 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_identifier ++)) (~ g!_left) (~ g!_right))
                    (-> (~ g!type) (~ g!type) (~ g!type))
                    (~ (|> g!tags+
                           (list#each (function (_ tag)
                                        (list tag (` (or (value@ (~ tag) (~ g!_left))
                                                         (value@ (~ 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)))