myco 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc8d9aa903a16793652f0a984ea68b5dc0058dee
-  data.tar.gz: 0ed0d4a3adb25552541a384019deeb7016d67057
+  metadata.gz: 9ac82f91bb59e1b38407f56839dc6f9a8a747813
+  data.tar.gz: d81314ee8a56b8950c7a42d253c77476ecef51e3
 SHA512:
-  metadata.gz: d50aa9cdf66fec631609560ea0c5bac80a39a27be523ca32ad1529795cbb0aab4cf9db3b11b55e30718e86191915c86ec95edec7ee9562d0bb687ad13f1025c3
-  data.tar.gz: c9ec127069f005ad5ba684b2a0fec708d7d8abceb297283838d323a14f65e0fe6df211840abf4cdbcce92db437c8b760049d2134ba30be15690c738a808d5fa5
+  metadata.gz: d594ed1f2693c0445ab02729a0f435ed13ca18251d4e9fd72b2b1070594e0fee3c7d3aa606936f57852fa41c1591f4250163463db690c91463ddc35aab6115d6
+  data.tar.gz: 2377868fe82a9a3fba6e5fdff7df63859d06c3514152661c32b89225f3d996501d5f363fa648645a727219b60441cfaa5a7536b0ee916adf162d182f33e03f91

data/lib/myco/code_tools/AST/ArgumentAssembly.my.rb

@@ -1,13 +1,13 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:ArgumentAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::ArgumentAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :argass,
     :body
-  ]))
+  ])
   declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given_body| (
     ::Myco.branch_op(:"&&", given_body.last.__send__(
       :is_a?,
@@ -51,5 +51,5 @@
       :send_with_block
     )) {self.block_bytecode(g)}
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :ArgumentAssembly })})}}.instance

data/lib/myco/code_tools/AST/ArrayAssembly.my.rb

@@ -1,12 +1,12 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:ArrayAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::ArrayAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :arrass,
     :body
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.__send__(:empty?)) {g.make_array(0)}) {(
@@ -33,5 +33,5 @@
       )})}
     )}
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :ArrayAssembly })})}}.instance

data/lib/myco/code_tools/AST/Block.my

@@ -0,0 +1,104 @@
+
+CodeTools::AST << {
+  
+  Block < CodeTools::Compiler::LocalVariables, Node {
+    var parameters, var body
+    var parent # TODO: investigate removing
+    
+    Form: [:block, :parameters, :body]
+    
+    CompilerClass: CodeTools::Compiler # TODO: remove this
+    
+    setter parameters: |given| given || ParameterAssembly.new(line:self.line)
+    setter body:      |given| given || NullLiteral.new(line:self.line)
+    
+    locals: self.body.?locals.?body.map(&:value) ?? null
+    
+    block_local?: |name|
+      locals.?include?(name) ?? false
+    
+    module?: false
+    
+    nest_scope: |scope| scope.parent = self
+    
+    # Look up a local variable in this block's scope.
+    search_local: |name| {
+      (variable = self.variables[name]) &? (
+        variable.nested_reference
+      ) ?? (self.block_local?(name) &? (
+        self.new_local(name)
+      ) ?? ((reference = self.parent.search_local(name)) &? (
+        reference.depth = reference.depth + 1
+        reference
+      ) ?? (
+        null
+      )))
+    }
+    
+    # Assign a slot number to a local variable access node.
+    # TODO: remove this method in favor of using search_local in all cases instead.
+    assign_local_reference: |var| {
+      var.variable = (variable = self.variables[var.name]) &? (
+        variable.reference
+      ) ?? (self.block_local?(var.name) &? (
+        variable = self.new_local(var.name)
+        variable.reference
+      ) ?? ((reference = self.parent.search_local(var.name)) &? (
+        reference.depth = reference.depth + 1
+        reference
+      ) ?? (
+        variable = self.new_local(var.name)
+        variable.reference
+      )))
+    }
+    
+    new_local: |name| {
+      self.variables[name] = \
+        self.variables[name] || CompilerClass::LocalVariable.new(allocate_slot)
+    }
+    
+    new_nested_local: |name| new_local(name).nested_reference
+    
+    bytecode: |g| {
+      pos(g)
+      
+      state = g.state
+      state.scope.nest_scope(self)
+      
+      blk = new_block_generator(g, self.parameters)
+      
+      blk.push_state(self)
+      blk.definition_line(self.line)
+      blk.state.push_super(state.super)
+      blk.state.push_eval(state.eval)
+      
+      blk.state.push_name(blk.name)
+      
+      # Push line info down.
+      pos(blk)
+      
+      self.parameters.bytecode(blk)
+      
+      blk.state.push_block
+      blk.push_modifiers
+      blk.break = null
+      blk.next = null
+      blk.redo = blk.new_label
+      blk.redo.set!
+      
+      self.body.bytecode(blk)
+      
+      blk.pop_modifiers
+      blk.state.pop_block
+      blk.ret
+      blk.close
+      blk.pop_state
+      
+      blk.local_count = local_count
+      blk.local_names = local_names
+      
+      g.create_block(blk)
+    }
+  }
+  
+}

data/lib/myco/code_tools/AST/Block.my.rb

@@ -0,0 +1,126 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::Block = ::Myco::Component.new([
+  ::Myco.find_constant(:CodeTools)::Compiler::LocalVariables,
+  ::Myco.find_constant(:Node)
+], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:parameters, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition::Form = ([
+    :block,
+    :parameters,
+    :body
+  ])
+  ::Myco.cscope.for_method_definition::CompilerClass = (::Myco.find_constant(:CodeTools)::Compiler)
+  declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})})}
+  declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
+  declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ((self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).respond_to?(:body).false? ? ::Myco::Void : (self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
+  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (self.locals.respond_to?(:include?).false? ? ::Myco::Void : self.locals.__send__(
+    :include?,
+    name
+  ))) {false})}
+  declare_meme(:module?, [], nil, ::Myco.cscope.dup) { |*| (false)}
+  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
+    :parent=,
+    self
+  ))}
+  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
+    :[],
+    name
+  )) {variable.nested_reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
+    :block_local?,
+    name
+  )) {self.new_local(name)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(name)) {(
+    reference.__send__(
+      :depth=,
+      reference.depth.__send__(
+        :+,
+        1
+      )
+    )
+    reference
+  )}) {nil}}})}
+  declare_meme(:assign_local_reference, [], nil, ::Myco.cscope.dup) { |var| (var.__send__(
+    :variable=,
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
+      :[],
+      var.name
+    )) {variable.reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
+      :block_local?,
+      var.name
+    )) {(
+      variable = self.new_local(var.name)
+      variable.reference
+    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(var.name)) {(
+      reference.__send__(
+        :depth=,
+        reference.depth.__send__(
+          :+,
+          1
+        )
+      )
+      reference
+    )}) {(
+      variable = self.new_local(var.name)
+      variable.reference
+    )}}}
+  ))}
+  declare_meme(:new_local, [], nil, ::Myco.cscope.dup) { |name| (self.variables.__send__(
+    :[]=,
+    name,
+    ::Myco.branch_op(:"||", self.variables.__send__(
+      :[],
+      name
+    )) {::Myco.find_constant(:CompilerClass)::LocalVariable.new(self.allocate_slot)}
+  ))}
+  declare_meme(:new_nested_local, [], nil, ::Myco.cscope.dup) { |name| (self.new_local(name).nested_reference)}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    state = g.state
+    state.scope.nest_scope(self)
+    blk = self.new_block_generator(
+      g,
+      self.parameters
+    )
+    blk.push_state(self)
+    blk.definition_line(self.line)
+    blk.state.push_super(state.super)
+    blk.state.push_eval(state.eval)
+    blk.state.push_name(blk.name)
+    self.pos(blk)
+    self.parameters.bytecode(blk)
+    blk.state.push_block
+    blk.push_modifiers
+    blk.__send__(
+      :break=,
+      nil
+    )
+    blk.__send__(
+      :next=,
+      nil
+    )
+    blk.__send__(
+      :redo=,
+      blk.new_label
+    )
+    blk.redo.__send__(:set!)
+    self.body.bytecode(blk)
+    blk.pop_modifiers
+    blk.state.pop_block
+    blk.ret
+    blk.close
+    blk.pop_state
+    blk.__send__(
+      :local_count=,
+      self.local_count
+    )
+    blk.__send__(
+      :local_names=,
+      self.local_names
+    )
+    g.create_block(blk)
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Block })})}}.instance

data/lib/myco/code_tools/AST/BlockArgument.my.rb

@@ -1,12 +1,12 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BlockArgument, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::BlockArgument = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :blkarg,
     :body
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.body.bytecode(g)
     done_label = g.new_label
@@ -22,5 +22,5 @@
     )
     done_label.__send__(:set!)
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :BlockArgument })})}}.instance

data/lib/myco/code_tools/AST/BlockLiteral.my

@@ -1,104 +1,25 @@
 
 CodeTools::AST << {
   
-  BlockLiteral < CodeTools::Compiler::LocalVariables, Node {
-    var parameters, var body
-    var parent # TODO: investigate removing
+  BlockLiteral < Node {
+    var block
     
-    Form: [:blklit, :parameters, :body]
+    Form: [:blklit, :block]
     
-    CompilerClass: CodeTools::Compiler # TODO: remove this
+    implementation_receiver: ConstantAccess.new(
+      line:     self.line
+      toplevel: true
+      names:    [:"Proc"]
+    )
     
-    setter parameters: |given| given || ParameterAssembly.new(line:self.line)
-    setter body:      |given| given || NullLiteral.new(line:self.line)
+    implementation: Invoke.new(
+      line:         self.line
+      receiver:     self.implementation_receiver
+      name:         (:new)
+      block:        self.block
+    )
     
-    locals: self.body.?locals.?body.map(&:value) ?? null
-    
-    block_local?: |name|
-      locals.?include?(name) ?? false
-    
-    module?: false
-    
-    nest_scope: |scope| scope.parent = self
-    
-    # Look up a local variable in this block's scope.
-    search_local: |name| {
-      (variable = self.variables[name]) &? (
-        variable.nested_reference
-      ) ?? (self.block_local?(name) &? (
-        self.new_local(name)
-      ) ?? ((reference = self.parent.search_local(name)) &? (
-        reference.depth = reference.depth + 1
-        reference
-      ) ?? (
-        null
-      )))
-    }
-    
-    # Assign a slot number to a local variable access node.
-    # TODO: remove this method in favor of using search_local in all cases instead.
-    assign_local_reference: |var| {
-      var.variable = (variable = self.variables[var.name]) &? (
-        variable.reference
-      ) ?? (self.block_local?(var.name) &? (
-        variable = self.new_local(var.name)
-        variable.reference
-      ) ?? ((reference = self.parent.search_local(var.name)) &? (
-        reference.depth = reference.depth + 1
-        reference
-      ) ?? (
-        variable = self.new_local(var.name)
-        variable.reference
-      )))
-    }
-    
-    new_local: |name| {
-      self.variables[name] = \
-        self.variables[name] || CompilerClass::LocalVariable.new(allocate_slot)
-    }
-    
-    new_nested_local: |name| new_local(name).nested_reference
-    
-    bytecode: |g| {
-      pos(g)
-      
-      state = g.state
-      state.scope.nest_scope(self)
-      
-      blk = new_block_generator(g, self.parameters)
-      
-      blk.push_state(self)
-      blk.definition_line(self.line)
-      blk.state.push_super(state.super)
-      blk.state.push_eval(state.eval)
-      
-      blk.state.push_name(blk.name)
-      
-      # Push line info down.
-      pos(blk)
-      
-      self.parameters.bytecode(blk)
-      
-      blk.state.push_block
-      blk.push_modifiers
-      blk.break = null
-      blk.next = null
-      blk.redo = blk.new_label
-      blk.redo.set!
-      
-      self.body.bytecode(blk)
-      
-      blk.pop_modifiers
-      blk.state.pop_block
-      blk.ret
-      blk.close
-      blk.pop_state
-      
-      blk.local_count = local_count
-      blk.local_names = local_names
-      
-      g.create_block(blk)
-    }
+    bytecode: |g| implementation.bytecode(g)
   }
   
 }

data/lib/myco/code_tools/AST/BlockLiteral.my.rb

@@ -1,126 +1,23 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BlockLiteral, ::Myco::Component.new([
-  ::Myco.find_constant(:CodeTools)::Compiler::LocalVariables,
-  ::Myco.find_constant(:Node)
-], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::BlockLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:parameters, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition::Form = ([
     :blklit,
-    :parameters,
-    :body
-  ]))
-  ::Myco.cscope.for_method_definition.const_set(:CompilerClass, (::Myco.find_constant(:CodeTools)::Compiler))
-  declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})})}
-  declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
-  declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ((self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).respond_to?(:body).false? ? ::Myco::Void : (self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
-  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (self.locals.respond_to?(:include?).false? ? ::Myco::Void : self.locals.__send__(
-    :include?,
-    name
-  ))) {false})}
-  declare_meme(:module?, [], nil, ::Myco.cscope.dup) { |*| (false)}
-  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
-    :parent=,
-    self
-  ))}
-  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
-    :[],
-    name
-  )) {variable.nested_reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
-    :block_local?,
-    name
-  )) {self.new_local(name)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(name)) {(
-    reference.__send__(
-      :depth=,
-      reference.depth.__send__(
-        :+,
-        1
-      )
-    )
-    reference
-  )}) {nil}}})}
-  declare_meme(:assign_local_reference, [], nil, ::Myco.cscope.dup) { |var| (var.__send__(
-    :variable=,
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
-      :[],
-      var.name
-    )) {variable.reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
-      :block_local?,
-      var.name
-    )) {(
-      variable = self.new_local(var.name)
-      variable.reference
-    )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(var.name)) {(
-      reference.__send__(
-        :depth=,
-        reference.depth.__send__(
-          :+,
-          1
-        )
-      )
-      reference
-    )}) {(
-      variable = self.new_local(var.name)
-      variable.reference
-    )}}}
-  ))}
-  declare_meme(:new_local, [], nil, ::Myco.cscope.dup) { |name| (self.variables.__send__(
-    :[]=,
-    name,
-    ::Myco.branch_op(:"||", self.variables.__send__(
-      :[],
-      name
-    )) {::Myco.find_constant(:CompilerClass)::LocalVariable.new(self.allocate_slot)}
-  ))}
-  declare_meme(:new_nested_local, [], nil, ::Myco.cscope.dup) { |name| (self.new_local(name).nested_reference)}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    state = g.state
-    state.scope.nest_scope(self)
-    blk = self.new_block_generator(
-      g,
-      self.parameters
-    )
-    blk.push_state(self)
-    blk.definition_line(self.line)
-    blk.state.push_super(state.super)
-    blk.state.push_eval(state.eval)
-    blk.state.push_name(blk.name)
-    self.pos(blk)
-    self.parameters.bytecode(blk)
-    blk.state.push_block
-    blk.push_modifiers
-    blk.__send__(
-      :break=,
-      nil
-    )
-    blk.__send__(
-      :next=,
-      nil
-    )
-    blk.__send__(
-      :redo=,
-      blk.new_label
-    )
-    blk.redo.__send__(:set!)
-    self.body.bytecode(blk)
-    blk.pop_modifiers
-    blk.state.pop_block
-    blk.ret
-    blk.close
-    blk.pop_state
-    blk.__send__(
-      :local_count=,
-      self.local_count
-    )
-    blk.__send__(
-      :local_names=,
-      self.local_names
-    )
-    g.create_block(blk)
-  )}
-)}})
+    :block
+  ])
+  declare_meme(:implementation_receiver, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAccess).new({
+    :line => self.line,
+    :toplevel => true,
+    :names => [:Proc]
+  }))}
+  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Invoke).new({
+    :line => self.line,
+    :receiver => self.implementation_receiver,
+    :name => :new,
+    :block => self.block
+  }))}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.implementation.bytecode(g))}
+)}}
 .tap { |__c__| __c__.__name__ = :BlockLiteral })})}}.instance

data/lib/myco/code_tools/AST/BlockParameter.my.rb

@@ -1,13 +1,13 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BlockParameter, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::BlockParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:name, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:variable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :blkprm,
     :name
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     g.push_proc
@@ -20,5 +20,5 @@
     )}) {g.set_local(self.variable.slot)}
     g.pop
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :BlockParameter })})}}.instance

data/lib/myco/code_tools/AST/BranchOperator.my.rb

@@ -1,16 +1,16 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BranchOperator, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::BranchOperator = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:type, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:left, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:right, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :branch_op,
     :type,
     :left,
     :right
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     done_label = g.new_label
@@ -83,5 +83,5 @@
     self.right.bytecode(g)
     done_label.__send__(:set!)
   )}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :BranchOperator })})}}.instance

data/lib/myco/code_tools/AST/ConstantAccess.my.rb

@@ -1,14 +1,14 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:ConstantAccess, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition::ConstantAccess = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   declare_meme(:toplevel, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
   declare_meme(:names, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+  ::Myco.cscope.for_method_definition::Form = ([
     :const,
     :toplevel,
     :names
-  ]))
+  ])
   declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
     self.pos(g)
     name_list = self.names.map(&:to_sym)
@@ -32,5 +32,5 @@
       2
     )
   )})}
-)}})
+)}}
 .tap { |__c__| __c__.__name__ = :ConstantAccess })})}}.instance