myco 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10d6d42881d428ea5359f83d8bfdce81ebf34ea7
-  data.tar.gz: fa2936dff1fbf455e7b8462c1c969cc023de020b
+  metadata.gz: 6ee9e5cedec16c7d921644a998eec8c6ee901443
+  data.tar.gz: c94e691503c0b83682e51a292f9bee7007be22c1
 SHA512:
-  metadata.gz: 9663e17bf43f6b64241939eafeb51350bb6a7298add9322c815f4ed4dec266efa93398ad4c27243bdfd20524a314c6cc8a0eaf6f8f3016dc807660df07bd65e5
-  data.tar.gz: da1ebe5deab665ceef785c9ddb89cb62fd6e551d616c8bbacb0af15fd590cdaf32a10597d051dab58fc4476290003dde6bcda25f9fcbc3ed8b27479dfe7b515d
+  metadata.gz: 1296828e31cb12b25fc17bee1d92e6922e5a0767e1347bcf374a00975d35652d0ef081967e29f6fa90fbcf7c9e6e279df3f6c6bf23b71f4dc362ef50d78251fc
+  data.tar.gz: d8cd85ae93f67d7670fd4cfb7b52a0e56a609f777c5ac33f1a03797c9b7a2055edea6a6b7e286b340a824d4396307f9a46be5c5ad41d93a574a202966ccef964

data/lib/myco/bootstrap.my.rb

@@ -2,10 +2,14 @@
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
   ::Myco::RubyEval = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Object.__send__(
-    :eval,
-    string
-  ))})}}
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(
+    :from_string,
+    [],
+    ::Object::Proc.new { |string| (::Object.__send__(
+      :eval,
+      string
+    ))}
+  ))}}
   .tap { |__c__| __c__.__name__ = :RubyEval }
   ::Myco::Category = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
@@ -26,21 +30,53 @@
   .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
   .tap { |__c__| __c__.__name__ = :FileToplevel }
   __category__(:decorators).component_eval {(
-    declare_meme(:load, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:LoadDecorator))}
+    declare_meme(
+      :load,
+      [],
+      ::Object::Proc.new { |*| (::Myco.find_constant(:LoadDecorator))}
+    )
     ::Myco.cscope.for_method_definition::LoadDecorator = (::Myco::Component.new([::Myco::Decorator], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
     .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (::Myco.eval_file(
-        meme.name.to_s,
-        [::Myco::CoreLoadPath]
+      declare_meme(
+        :apply,
+        [],
+        ::Object::Proc.new { |meme| (::Myco.eval_file(
+          meme.name.to_s,
+          [::Myco::CoreLoadPath]
+        ))}
+      )
+      __category__(:transforms).component_eval {(declare_meme(
+        :apply,
+        [],
+        ::Object::Proc.new { |*| nil}
       ))}
-      __category__(:transforms).component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |*| nil})}
     )}}.instance)
   )}
   __category__(:main).component_eval {(
-    declare_meme(:"core/Category.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:"core/Decorator.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:"core/BasicDecorators.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:"core/BasicObject.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
-    declare_meme(:"core/FileToplevel.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(
+      :"core/Category.my",
+      [:load],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :"core/Decorator.my",
+      [:load],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :"core/BasicDecorators.my",
+      [:load],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :"core/BasicObject.my",
+      [:load],
+      ::Object::Proc.new { |*| nil}
+    )
+    declare_meme(
+      :"core/FileToplevel.my",
+      [:load],
+      ::Object::Proc.new { |*| nil}
+    )
   )}
 )}}.instance

data/lib/myco/bootstrap/add_method.rb

@@ -3,8 +3,8 @@ module Myco
   # In Myco, try to always use Myco.add_method instead of Rubinius.add_method
   # to bypass all of the Ruby-specific logic therein.
   
-  def self.add_method mod, name, executable
-    mod.method_table.store(name, executable, :public)
+  def self.add_method mod, name, executable, cscope
+    mod.method_table.store(name, nil, executable, cscope, 0, :public)
     Rubinius::VM.reset_method_cache(mod, name)
   end
   
@@ -14,7 +14,7 @@ module Myco
   
   # Use instead of Module#thunk_method
   def self.add_thunk_method mod, name, value
-    add_method(mod, name, Rubinius::Thunk.new(value))
+    add_method(mod, name, Rubinius::Thunk.new(value), nil)
   end
   
   # Use instead of Module#dynamic_method
@@ -31,8 +31,8 @@ module Myco
     g.encode
 
     code = g.package Rubinius::CompiledCode
-    code.scope = Rubinius::ConstantScope.new(mod, Rubinius::ConstantScope.new(Myco))
+    cscope = Rubinius::ConstantScope.new(mod, Rubinius::ConstantScope.new(Myco))
 
-    add_method(mod, name, code)
+    add_method(mod, name, code, cscope)
   end
 end

data/lib/myco/bootstrap/meme.rb

@@ -152,7 +152,8 @@ module Myco
         bind_cache_method
         @effective_body = @target.instance_method(@name).executable
       else
-        Myco.add_method(@target, @name, @body)
+        cscope = @body.respond_to?(:scope) ? @body.scope : nil
+        Myco.add_method(@target, @name, @body, cscope)
       end
     end
     

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

@@ -2,7 +2,7 @@
 ::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::BuilderMethods = (::Myco.find_constant(:Module).new { || nil})
+    ::Myco.cscope.for_method_definition::BuilderMethods = (::Myco.find_constant(:Module).new { |*| nil})
     ::Myco.cscope.for_method_definition::Builder = ::Myco::Component.new([
       ::Myco.find_constant(:BasicObject),
       ::Myco.find_constant(:BuilderMethods)
@@ -10,46 +10,214 @@
     .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
     .tap { |__c__| __c__.__name__ = :Builder }
   )}
-  declare_meme(:"AST/Node.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Script.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/NumericLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/StringLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/SymbolLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/StringCompose.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/SymbolCompose.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Sequence.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/SplatValue.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ArrayAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/KeywordAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ArgumentAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BlockArgument.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Block.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/RequiredParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/OptionalParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/RestParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/KeywordRequiredParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/KeywordOptionalParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/KeywordRestParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BlockParameter.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ParameterAssembly.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BlockLiteral.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ConstantAccess.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ConstantAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ConstantDefine.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclaredScope.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareObject.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareString.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareFile.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareExtension.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareCategory.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/DeclareMeme.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Invoke.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/InvokeMethod.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/LocalVariableAccessAmbiguous.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/LocalVariableAssignment.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/Quest.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/BranchOperator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/PipeOperator.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/misc.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:"AST/ToRuby.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(
+    :"AST/Node.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/Script.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/NumericLiteral.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/StringLiteral.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/SymbolLiteral.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/StringCompose.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/SymbolCompose.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/Sequence.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/SplatValue.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ArrayAssembly.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/KeywordAssembly.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ArgumentAssembly.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/BlockArgument.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/Block.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/RequiredParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/OptionalParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/RestParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/KeywordRequiredParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/KeywordOptionalParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/KeywordRestParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/BlockParameter.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ParameterAssembly.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/BlockLiteral.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ConstantAccess.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ConstantAssignment.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ConstantDefine.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclaredScope.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareObject.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareString.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareFile.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareExtension.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareCategory.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/DeclareMeme.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/Invoke.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/InvokeMethod.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/LocalVariableAccessAmbiguous.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/LocalVariableAssignment.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/Quest.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/BranchOperator.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/PipeOperator.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/misc.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :"AST/ToRuby.my",
+    [:import],
+    ::Object::Proc.new { |*| nil}
+  )
 )}}.instance

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

@@ -2,57 +2,101 @@
 ::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::ArgumentAssembly = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:args, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:field, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given_body| (
-    ::Myco.branch_op(:"&&", given_body.last.__send__(
-      :is_a?,
-      ::Myco.find_constant(:BlockArgument)
-    )) {self.__send__(
-      :block=,
-      given_body.pop
+  declare_meme(
+    :args,
+    [:node_type],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:field],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :block,
+    [:var],
+    ::Object::Proc.new { |*| nil}
+  )
+  declare_meme(
+    :body,
+    [:setter],
+    ::Object::Proc.new { |given_body| (
+      ::Myco.branch_op(:"&&", given_body.last.__send__(
+        :is_a?,
+        ::Myco.find_constant(:BlockArgument)
+      )) {self.__send__(
+        :block=,
+        given_body.pop
+      )}
+      given_body
     )}
-    given_body
-  )}
-  declare_meme(:pre_group, [], nil, ::Myco.cscope.dup) { |*| (self.body.take_while { |item| (item.__send__(
-    :is_a?,
-    ::Myco.find_constant(:SplatValue)
-  ).__send__(:!))})}
-  declare_meme(:post_group, [], nil, ::Myco.cscope.dup) { |*| (self.body.drop_while { |item| (item.__send__(
-    :is_a?,
-    ::Myco.find_constant(:SplatValue)
-  ).__send__(:!))})}
-  declare_meme(:send_op, [], nil, ::Myco.cscope.dup) { |*| (self.cond(
-    self.body.detect { |item| (item.__send__(
+  )
+  declare_meme(
+    :pre_group,
+    [],
+    ::Object::Proc.new { |*| (self.body.take_while { |item| (item.__send__(
+      :is_a?,
+      ::Myco.find_constant(:SplatValue)
+    ).__send__(:!))})}
+  )
+  declare_meme(
+    :post_group,
+    [],
+    ::Object::Proc.new { |*| (self.body.drop_while { |item| (item.__send__(
       :is_a?,
       ::Myco.find_constant(:SplatValue)
-    ))},
-    :send_with_splat,
-    self.block,
-    :send_with_block,
-    :send
-  ))}
-  declare_meme(:send_count, [], nil, ::Myco.cscope.dup) { |*| (self.pre_group.size)}
-  declare_meme(:splat_bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.find_constant(:ArrayAssembly).new({
-    :line => self.line,
-    :body => self.post_group
-  }).bytecode(g))}
-  declare_meme(:block_bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {self.block.bytecode(g)}) {g.push_null})}
-  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
-    self.pos(g)
-    self.pre_group.each { |item| (item.bytecode(g))}
-    ::Myco.branch_op(:"&&", self.send_op.__send__(
-      :==,
-      :send_with_splat
-    )) {(
-      self.splat_bytecode(g)
-      self.block_bytecode(g)
+    ).__send__(:!))})}
+  )
+  declare_meme(
+    :send_op,
+    [],
+    ::Object::Proc.new { |*| (self.cond(
+      self.body.detect { |item| (item.__send__(
+        :is_a?,
+        ::Myco.find_constant(:SplatValue)
+      ))},
+      :send_with_splat,
+      self.block,
+      :send_with_block,
+      :send
+    ))}
+  )
+  declare_meme(
+    :send_count,
+    [],
+    ::Object::Proc.new { |*| (self.pre_group.size)}
+  )
+  declare_meme(
+    :splat_bytecode,
+    [],
+    ::Object::Proc.new { |g| (::Myco.find_constant(:ArrayAssembly).new({
+      :line => self.line,
+      :body => self.post_group
+    }).bytecode(g))}
+  )
+  declare_meme(
+    :block_bytecode,
+    [],
+    ::Object::Proc.new { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {self.block.bytecode(g)}) {g.push_null})}
+  )
+  declare_meme(
+    :bytecode,
+    [],
+    ::Object::Proc.new { |g| (
+      self.pos(g)
+      self.pre_group.each { |item| (item.bytecode(g))}
+      ::Myco.branch_op(:"&&", self.send_op.__send__(
+        :==,
+        :send_with_splat
+      )) {(
+        self.splat_bytecode(g)
+        self.block_bytecode(g)
+      )}
+      ::Myco.branch_op(:"&&", self.send_op.__send__(
+        :==,
+        :send_with_block
+      )) {self.block_bytecode(g)}
     )}
-    ::Myco.branch_op(:"&&", self.send_op.__send__(
-      :==,
-      :send_with_block
-    )) {self.block_bytecode(g)}
-  )}
+  )
 )}}
 .tap { |__c__| __c__.__name__ = :ArgumentAssembly })})}}.instance