myco 0.1.9 → 0.1.10

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

@@ -2,33 +2,45 @@
 ::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::ArrayAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:array, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  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)}) {(
-      chunked = self.body.chunk { |item| (item.__send__(
-        :is_a?,
-        ::Myco.find_constant(:SplatValue)
-      ))}
-      first_bytecode = true
-      chunked.each { |is_splat_group, group| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", is_splat_group) {group.each { |item| (
-        item.bytecode(g)
-        ::Myco.branch_op(:"||", first_bytecode) {g.send(
-          :concat,
-          1
-        )}
-        first_bytecode = false
-      )}}) {(
-        group.each { |item| (item.bytecode(g))}
-        g.make_array(group.size)
-        ::Myco.branch_op(:"||", first_bytecode) {g.send(
-          :concat,
-          1
-        )}
-        first_bytecode = false
-      )})}
+  declare_meme(
+    :array,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.__send__(:empty?)) {g.make_array(0)}) {(
+        chunked = self.body.chunk { |item| (item.__send__(
+          :is_a?,
+          ::Myco.find_constant(:SplatValue)
+        ))}
+        first_bytecode = true
+        chunked.each { |is_splat_group, group| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", is_splat_group) {group.each { |item| (
+          item.bytecode(g)
+          ::Myco.branch_op(:"||", first_bytecode) {g.send(
+            :concat,
+            1
+          )}
+          first_bytecode = false
+        )}}) {(
+          group.each { |item| (item.bytecode(g))}
+          g.make_array(group.size)
+          ::Myco.branch_op(:"||", first_bytecode) {g.send(
+            :concat,
+            1
+          )}
+          first_bytecode = false
+        )})}
+      )}
     )}
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :ArrayAssembly })})}}.instance

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

@@ -5,51 +5,73 @@
   ::Myco.find_constant(:Node)
 ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:block, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:parameters, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:parent, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:new_cscope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(
+    :block,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :parameters,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :parent,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :new_cscope,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
   ::Myco.cscope.for_method_definition::CompilerClass = (::Myco.find_constant(:CodeTools)::Compiler)
-  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(:"??", (Rubinius::Type.object_respond_to?((Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals), :body).false? ? ::Myco::Void : (Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
-  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.locals, :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__(
+  declare_meme(
+    :body,
+    [:setter],
+    ::Object::Proc.new { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
+  )
+  declare_meme(
+    :locals,
+    [],
+    ::Object::Proc.new { |*| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?((Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals), :body).false? ? ::Myco::Void : (Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
+  )
+  declare_meme(
     :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__(
+    [],
+    ::Object::Proc.new { |name| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.locals, :include?).false? ? ::Myco::Void : self.locals.__send__(
+      :include?,
+      name
+    ))) {false})}
+  )
+  declare_meme(
+    :module?,
+    [],
+    ::Object::Proc.new { |*| (false)}
+  )
+  declare_meme(
+    :nest_scope,
+    [],
+    ::Object::Proc.new { |scope| (scope.__send__(
+      :parent=,
+      self
+    ))}
+  )
+  declare_meme(
+    :search_local,
+    [],
+    ::Object::Proc.new { |name| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", variable = self.variables.__send__(
       :[],
-      var.name
-    )) {variable.reference}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.__send__(
+      name
+    )) {variable.nested_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)) {(
+      name
+    )) {self.new_local(name)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", reference = self.parent.search_local(name)) {(
       reference.__send__(
         :depth=,
         reference.depth.__send__(
@@ -58,78 +80,120 @@
         )
       )
       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(:effective_parameters, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"||", self.parameters) {::Myco.find_constant(:ParameterAssembly).new({
-    :line => self.line,
-    :rest => ::Myco.find_constant(:RestParameter).new({:line => self.line})
-  })})}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    state = g.state
-    state.scope.nest_scope(self)
-    parameters = self.effective_parameters
-    blk = self.new_block_generator(
-      g,
-      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)
-    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
-    )
-    ::Myco.branch_op(:"&?", self.new_cscope) {(
-      g.push_scope
-      g.send(
-        :for_method_definition,
-        0
+    )}) {nil}}})}
+  )
+  declare_meme(
+    :assign_local_reference,
+    [],
+    ::Object::Proc.new { |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,
+    [],
+    ::Object::Proc.new { |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,
+    [],
+    ::Object::Proc.new { |name| (self.new_local(name).nested_reference)}
+  )
+  declare_meme(
+    :effective_parameters,
+    [],
+    ::Object::Proc.new { |*| (::Myco.branch_op(:"||", self.parameters) {::Myco.find_constant(:ParameterAssembly).new({
+      :line => self.line,
+      :rest => ::Myco.find_constant(:RestParameter).new({:line => self.line})
+    })})}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      state = g.state
+      state.scope.nest_scope(self)
+      parameters = self.effective_parameters
+      blk = self.new_block_generator(
+        g,
+        parameters
       )
-      g.add_scope
+      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)
+      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
+      )
+      ::Myco.branch_op(:"&?", self.new_cscope) {(
+        g.push_scope
+        g.send(
+          :for_method_definition,
+          0
+        )
+        g.add_scope
+      )}
+      g.create_block(blk)
     )}
-    g.create_block(blk)
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Block })})}}.instance

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

@@ -2,22 +2,34 @@
 ::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::BlockArgument = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:blkarg, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.body.bytecode(g)
-    done_label = g.new_label
-    g.dup
-    g.is_nil
-    g.goto_if_true(done_label)
-    g.push_cpath_top
-    g.find_const(:Proc)
-    g.swap
-    g.send(
-      :__from_block__,
-      1
-    )
-    done_label.__send__(:set!)
-  )}
+  declare_meme(
+    :blkarg,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.body.bytecode(g)
+      done_label = g.new_label
+      g.dup
+      g.is_nil
+      g.goto_if_true(done_label)
+      g.push_cpath_top
+      g.find_const(:Proc)
+      g.swap
+      g.send(
+        :__from_block__,
+        1
+      )
+      done_label.__send__(:set!)
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :BlockArgument })})}}.instance

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

@@ -2,22 +2,42 @@
 ::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::BlockLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:blklit, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:block, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:implementation_receiver, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ConstantAccess).new({
-    :line => self.line,
-    :toplevel => true,
-    :names => [
-      :Ruby,
-      :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))}
+  declare_meme(
+    :blklit,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :block,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :implementation_receiver,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:ConstantAccess).new({
+      :line => self.line,
+      :toplevel => true,
+      :names => [
+        :Ruby,
+        :Proc
+      ]
+    }))}
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:Invoke).new({
+      :line => self.line,
+      :receiver => self.implementation_receiver,
+      :name => :new,
+      :block => self.block
+    }))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (self.implementation.bytecode(g))}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :BlockLiteral })})}}.instance