myco 0.1.9 → 0.1.10

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

@@ -2,23 +2,47 @@
 ::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::PipeOperator = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:pipe_op, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:invoke, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:implementation_args, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ArgumentAssembly).new({
-    :line => self.line,
-    :body => [self.value].__send__(
-      :+,
-      ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.invoke.arguments, :body).false? ? ::Myco::Void : self.invoke.arguments.body)) {[]}
-    )
-  }))}
-  declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Invoke).new({
-    :line => self.line,
-    :receiver => self.invoke.receiver,
-    :name => self.invoke.name,
-    :arguments => self.implementation_args,
-    :block => self.invoke.block
-  }))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.implementation.bytecode(g))}
+  declare_meme(
+    :pipe_op,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :value,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :invoke,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :implementation_args,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:ArgumentAssembly).new({
+      :line => self.line,
+      :body => [self.value].__send__(
+        :+,
+        ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.invoke.arguments, :body).false? ? ::Myco::Void : self.invoke.arguments.body)) {[]}
+      )
+    }))}
+  )
+  declare_meme(
+    :implementation,
+    [],
+    ::Object::Proc.new { |*| (::Myco.find_constant(:Invoke).new({
+      :line => self.line,
+      :receiver => self.invoke.receiver,
+      :name => self.invoke.name,
+      :arguments => self.implementation_args,
+      :block => self.invoke.block
+    }))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (self.implementation.bytecode(g))}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :PipeOperator })})}}.instance

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

@@ -2,45 +2,73 @@
 ::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::Quest = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:quest, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:receiver, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:questable, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:questable, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (
-    given.__send__(
-      :receiver=,
-      ::Myco.find_constant(:FakeReceiver).new({:line => self.line})
-    )
-    given
-  )}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    else_label = g.new_label
-    end_label = g.new_label
-    self.receiver.bytecode(g)
-    g.dup_top
-    g.push_type
-    g.swap
-    g.push_literal(self.questable.name)
-    g.send(
-      :object_respond_to?,
-      2
-    )
-    g.send(
-      :false?,
-      0
-    )
-    g.goto_if_true(else_label)
-    self.questable.bytecode(g)
-    g.goto(end_label)
-    else_label.__send__(:set!)
-    g.pop
-    g.push_void
-    end_label.__send__(:set!)
-  )}
+  declare_meme(
+    :quest,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :receiver,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :questable,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :questable,
+    [:setter],
+    ::Object::Proc.new { |given| (
+      given.__send__(
+        :receiver=,
+        ::Myco.find_constant(:FakeReceiver).new({:line => self.line})
+      )
+      given
+    )}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      else_label = g.new_label
+      end_label = g.new_label
+      self.receiver.bytecode(g)
+      g.dup_top
+      g.push_type
+      g.swap
+      g.push_literal(self.questable.name)
+      g.send(
+        :object_respond_to?,
+        2
+      )
+      g.send(
+        :false?,
+        0
+      )
+      g.goto_if_true(else_label)
+      self.questable.bytecode(g)
+      g.goto(end_label)
+      else_label.__send__(:set!)
+      g.pop
+      g.push_void
+      end_label.__send__(:set!)
+    )}
+  )
   ::Myco.cscope.for_method_definition::FakeReceiver = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    declare_meme(:qrcvr, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.pos(g))}
+    declare_meme(
+      :qrcvr,
+      [:node_type],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :bytecode,
+      [],
+      ::Object::Proc.new { |g| (self.pos(g))}
+    )
   )}}
   .tap { |__c__| __c__.__name__ = :FakeReceiver }
 )}}

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

@@ -2,9 +2,25 @@
 ::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::RequiredParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:reqprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (scope.new_local(self.name))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| nil}
+  declare_meme(
+    :reqprm,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :map_local,
+    [],
+    ::Object::Proc.new { |scope| (scope.new_local(self.name))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| nil}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :RequiredParameter })})}}.instance

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

@@ -2,9 +2,25 @@
 ::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::RestParameter = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:restprm, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:name, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:map_local, [], nil, ::Myco.cscope.dup) { |scope| (scope.new_local(::Myco.branch_op(:"||", self.name) {:*}))}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| nil}
+  declare_meme(
+    :restprm,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :name,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :map_local,
+    [],
+    ::Object::Proc.new { |scope| (scope.new_local(::Myco.branch_op(:"||", self.name) {:*}))}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| nil}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :RestParameter })})}}.instance

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

@@ -2,28 +2,56 @@
 ::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::Script = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:script, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:file, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:variable_scope, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
-    :parent=,
-    self
-  ))}
-  declare_meme(:search_local, [], nil, ::Myco.cscope.dup) { |*| (nil)}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    g.__send__(
-      :name=,
-      :__script__
-    )
-    g.__send__(
-      :file=,
-      self.file.to_sym
-    )
-    g.push_state(self)
-    self.body.bytecode(g)
-    g.ret
-    g.pop_state
-  )}
+  declare_meme(
+    :script,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :file,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :variable_scope,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :nest_scope,
+    [],
+    ::Object::Proc.new { |scope| (scope.__send__(
+      :parent=,
+      self
+    ))}
+  )
+  declare_meme(
+    :search_local,
+    [],
+    ::Object::Proc.new { |*| (nil)}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      g.__send__(
+        :name=,
+        :__script__
+      )
+      g.__send__(
+        :file=,
+        self.file.to_sym
+      )
+      g.push_state(self)
+      self.body.bytecode(g)
+      g.ret
+      g.pop_state
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Script })})}}.instance

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

@@ -2,16 +2,28 @@
 ::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::Sequence = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:sequence, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:array, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    ary = self.array.dup
-    last = ary.pop
-    ary.each { |item| (
-      item.bytecode(g)
-      g.pop
+  declare_meme(
+    :sequence,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :array,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      ary = self.array.dup
+      last = ary.pop
+      ary.each { |item| (
+        item.bytecode(g)
+        g.pop
+      )}
+      last.bytecode(g)
     )}
-    last.bytecode(g)
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :Sequence })})}}.instance

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

@@ -2,21 +2,33 @@
 ::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::SplatValue = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:splat, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:value, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.value.bytecode(g)
-    g.dup
-    g.push_rubinius
-    g.find_const(:Runtime)
-    g.swap
-    g.send(
-      :dup_as_array,
-      1,
-      true
-    )
-    g.swap
-    g.pop
-  )}
+  declare_meme(
+    :splat,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :value,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.value.bytecode(g)
+      g.dup
+      g.push_rubinius
+      g.find_const(:Runtime)
+      g.swap
+      g.send(
+        :dup_as_array,
+        1,
+        true
+      )
+      g.swap
+      g.pop
+    )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :SplatValue })})}}.instance

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

@@ -2,18 +2,30 @@
 ::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::StringCompose = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:string_compose, [[: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)
-    self.body.each_slice(2) { |string, other| (
-      g.push_literal(string.value.to_s)
-      ::Myco.branch_op(:"&&", other) {(
-        other.bytecode(g)
-        g.meta_to_s
+  declare_meme(
+    :string_compose,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.body.each_slice(2) { |string, other| (
+        g.push_literal(string.value.to_s)
+        ::Myco.branch_op(:"&&", other) {(
+          other.bytecode(g)
+          g.meta_to_s
+        )}
       )}
+      g.string_build(self.body.size)
     )}
-    g.string_build(self.body.size)
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :StringCompose })})}}.instance