myco 0.1.6 → 0.1.7

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   Quest < Node {
-    var receiver, var questable
-    
-    Form: [:quest, :receiver, :questable]
+    node_type quest
+    field receiver, field questable
     
     setter questable: |given| {
       given.receiver = FakeReceiver.new(line: self.line)
@@ -15,7 +14,7 @@ CodeTools::AST << {
       pos(g)
       
       ##
-      # unless self.receiver.respond_to?(self.questable.name).false?
+      # unless Rubinius::Type.object_respond_to?(self.receiver, self.questable.name).false?
       #   execute_statement self.questable
       # else
       #   return void
@@ -25,9 +24,10 @@ CodeTools::AST << {
       end_label  = g.new_label
       
       self.receiver.bytecode(g)
-      g.dup_top # dup the receiver to save it for later
+        g.dup_top # dup the receiver to save it for later
+      g.push_type; g.swap
         g.push_literal(self.questable.name)
-      g.send(:"respond_to?", 1)
+      g.send(:"object_respond_to?", 2)
       g.send(:"false?", 0)
       g.goto_if_true(else_label)
       
@@ -39,16 +39,14 @@ CodeTools::AST << {
       
       else_label.set!
       g.pop # pop the duped receiver - it won't be used after all
-      g.push_cpath_top
-      g.find_const(:"Myco")
-      g.find_const(:"Void")
+      g.push_void
       
       end_label.set!
     }
     
     
     FakeReceiver < Node {
-      Form: [:qrcvr]
+      node_type qrcvr
       
       # Do nothing here - this would normally be ill-advised,
       # because Nodes are expected to push an item onto the stack,

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

@@ -2,13 +2,9 @@
 ::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(:receiver, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:questable, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :quest,
-    :receiver,
-    :questable
-  ])
+  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=,
@@ -22,10 +18,12 @@
     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(
-      :respond_to?,
-      1
+      :object_respond_to?,
+      2
     )
     g.send(
       :false?,
@@ -36,14 +34,12 @@
     g.goto(end_label)
     else_label.__send__(:set!)
     g.pop
-    g.push_cpath_top
-    g.find_const(:Myco)
-    g.find_const(:Void)
+    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 {(
-    ::Myco.cscope.for_method_definition::Form = ([:qrcvr])
+    declare_meme(:qrcvr, [[:node_type, []]], nil, ::Myco.cscope.dup) { |*| nil}
     declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (self.pos(g))}
   )}}
   .tap { |__c__| __c__.__name__ = :FakeReceiver }

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

@@ -0,0 +1,12 @@
+
+CodeTools::AST << {
+  
+  RequiredParameter < Node {
+    node_type reqprm
+    field name
+    
+    map_local: |scope| scope.new_local(self.name)
+    bytecode: |g| { }
+  }
+   
+}

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

@@ -0,0 +1,10 @@
+
+::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}
+)}}
+.tap { |__c__| __c__.__name__ = :RequiredParameter })})}}.instance

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

@@ -0,0 +1,12 @@
+
+CodeTools::AST << {
+  
+  RestParameter < Node {
+    node_type restprm
+    field name
+    
+    map_local: |scope| scope.new_local(self.name || :"*")
+    bytecode: |g| { }
+  }
+   
+}

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

@@ -0,0 +1,10 @@
+
+::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}
+)}}
+.tap { |__c__| __c__.__name__ = :RestParameter })})}}.instance

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

@@ -3,16 +3,16 @@ CodeTools::AST << {
   
   # TODO: consider moving out of the AST namespace - or maybe collapse into FileToplevel
   Script < Node {
-    var file, var body
-    var variable_scope # TODO: remove?
+    node_type script
+    field file, field body
     
-    Form: [:script, :file, :body]
+    var variable_scope # TODO: remove?
     
     nest_scope: |scope| scope.parent = self
     search_local: null # TODO: revisit and possibly implement for nested evals
     
     bytecode: |g| {
-      g.name = :"__script__"
+      g.name = :__script__
       g.file = self.file.to_sym
       
       g.push_state(self)

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

@@ -2,14 +2,10 @@
 ::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(:file, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  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}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :script,
-    :file,
-    :body
-  ])
   declare_meme(:nest_scope, [], nil, ::Myco.cscope.dup) { |scope| (scope.__send__(
     :parent=,
     self

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   Sequence < Node {
-    var array
-    
-    Form: [:sequence, :array]
+    node_type sequence
+    field array
     
     bytecode: |g| {
       ary = self.array.dup

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

@@ -2,11 +2,8 @@
 ::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(:array, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :sequence,
-    :array
-  ])
+  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

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   SplatValue < Node {
-    var value
-    
-    Form: [:splat, :value]
+    node_type splat
+    field value
     
     bytecode: |g| {
       self.value.bytecode(g)
@@ -12,7 +11,7 @@ CodeTools::AST << {
       # TODO: determine if coercion from other types is necessary here
       g.dup
       g.push_rubinius
-      g.find_const(:"Runtime")
+      g.find_const(:Runtime)
       g.swap
       g.send(:dup_as_array, 1, true)
       

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

@@ -2,11 +2,8 @@
 ::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(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :splat,
-    :value
-  ])
+  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

data/lib/myco/code_tools/AST/{DynamicString.my → StringCompose.my}

@@ -1,10 +1,9 @@
 
 CodeTools::AST << {
   
-  DynamicString < Node {
-    var body
-    
-    Form: [:dstr, :body]
+  StringCompose < Node {
+    node_type string_compose
+    field body
     
     bytecode: |g| {
       pos(g)

data/lib/myco/code_tools/AST/{DynamicString.my.rb → StringCompose.my.rb}

@@ -1,12 +1,9 @@
 
 ::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::DynamicString = ::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::StringCompose = ::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::Form = ([
-    :dstr,
-    :body
-  ])
+  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| (
@@ -19,4 +16,4 @@
     g.string_build(self.body.size)
   )}
 )}}
-.tap { |__c__| __c__.__name__ = :DynamicString })})}}.instance
+.tap { |__c__| __c__.__name__ = :StringCompose })})}}.instance

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   StringLiteral < Node {
-    var value
-    
-    Form: [:str, :value]
+    node_type str
+    field value
     
     bytecode: |g| {
       pos(g)

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

@@ -2,11 +2,8 @@
 ::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::StringLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :str,
-    :value
-  ])
+  declare_meme(:str, [[: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.pos(g)
     g.push_literal(self.value)

data/lib/myco/code_tools/AST/{DynamicSymbol.my → SymbolCompose.my}

@@ -1,10 +1,9 @@
 
 CodeTools::AST << {
   
-  DynamicSymbol < Node {
-    var body
-    
-    Form: [:dsym, :body]
+  SymbolCompose < Node {
+    node_type symbol_compose
+    field body
     
     bytecode: |g| {
       pos(g)

data/lib/myco/code_tools/AST/{DynamicSymbol.my.rb → SymbolCompose.my.rb}

@@ -1,12 +1,9 @@
 
 ::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::DynamicSymbol = ::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::SymbolCompose = ::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::Form = ([
-    :dsym,
-    :body
-  ])
+  declare_meme(:symbol_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| (
@@ -23,4 +20,4 @@
     )
   )}
 )}}
-.tap { |__c__| __c__.__name__ = :DynamicSymbol })})}}.instance
+.tap { |__c__| __c__.__name__ = :SymbolCompose })})}}.instance

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

@@ -2,9 +2,8 @@
 CodeTools::AST << {
   
   SymbolLiteral < Node {
-    var value
-    
-    Form: [:lit, :value]
+    node_type symbol
+    field value
     
     bytecode: |g| {
       pos(g)

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

@@ -2,11 +2,8 @@
 ::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::SymbolLiteral = ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  declare_meme(:value, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco.cscope.for_method_definition::Form = ([
-    :lit,
-    :value
-  ])
+  declare_meme(:symbol, [[: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.pos(g)
     g.push_literal(self.value)

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

@@ -104,25 +104,26 @@ CodeTools::AST << {
   TrueLiteral  << { to_ruby: |g| g.add("true") }
   FalseLiteral << { to_ruby: |g| g.add("false") }
   
-  StringLiteral << { to_ruby: |g| g.add(self.value.inspect) }
-  SymbolLiteral << { to_ruby: |g| g.add(self.value.inspect) }
+  NumericLiteral << { to_ruby: |g| g.add(self.value.inspect) }
+  StringLiteral  << { to_ruby: |g| g.add(self.value.inspect) }
+  SymbolLiteral  << { to_ruby: |g| g.add(self.value.inspect) }
   
-  DynamicString << {
+  StringCompose << {
     to_ruby: |g| {
       g.add('"')
         self.body.each_slice(2) |string, to_string| {
-          g.add(string.value.to_s.inspect.slice(::Range.new(1, -2)))
+          g.add(string.value.to_s.inspect.slice(Range.new(1, -2)))
           to_string && (g.add('#{'); g.add(to_string); g.add('}'))
         }
       g.add('"')
     }
   }
   
-  DynamicSymbol << {
+  SymbolCompose << {
     to_ruby: |g| {
       g.add(':"')
         self.body.each_slice(2) |string, to_string| {
-          g.add(string.value.to_s.inspect.slice(::Range.new(1, -2)))
+          g.add(string.value.to_s.inspect.slice(Range.new(1, -2)))
           to_string && (g.add('#{'); g.add(to_string); g.add('}'))
         }
       g.add('"')
@@ -150,7 +151,12 @@ CodeTools::AST << {
       first_name = name_list.shift
       
       self.toplevel &? (
-        g.add("::"first_name"")
+        first_name case(
+          :Myco,     &{ g.add("::Myco") },
+          :Ruby,     &{ g.add("::Object") },
+          :Rubinius, &{ g.add("::Rubinius") },
+                     &{ g.add("::Myco::"first_name"") }
+        )
       ) ?? (
         g.add("::Myco.find_constant("first_name.inspect")")
       )
@@ -165,7 +171,16 @@ CodeTools::AST << {
       first_name = name_list.any? && name_list.shift
       
       self.constant.toplevel &? (
-        first_name && g.add("::"first_name"")
+        first_name &? (
+          first_name case(
+            :Myco,     &{ g.add("::Myco") },
+            :Ruby,     &{ g.add("::Object") },
+            :Rubinius, &{ g.add("::Rubinius") },
+                       &{ g.add("::Myco::"first_name"") }
+          )
+        ) ?? (
+          g.add("::Myco")
+        )
       ) ?? (
         first_name &? (
           g.add("::Myco.find_constant("first_name.inspect")")
@@ -189,14 +204,14 @@ CodeTools::AST << {
     }
   }
   
-  ConstantReopen << {
+  DeclareExtension << {
     to_ruby: |g| {
       g.add(self.constant); g.add(".component_eval {")
       g.add(self.body); g.add("}")
     }
   }
   
-  MycoModuleScope << {
+  DeclaredScope << {
     to_ruby: |g|
       g.with_nested_var_scope(self) { g.add(self.body) }
   }
@@ -245,53 +260,19 @@ CodeTools::AST << {
     }
   }
   
-  BlockParameter << {
-    to_ruby: |g| g.add("&"self.name"")
-  }
+  RequiredParameter << { to_ruby: |g| g.add(""self.name"") }
+  OptionalParameter << { to_ruby: |g| g.add(""self.name"="); g.add(self.value) }
+  RestParameter     << { to_ruby: |g| g.add("*"self.name"") }
+  
+  KeywordRequiredParameter << { to_ruby: |g| g.add(""self.name":") }
+  KeywordOptionalParameter << { to_ruby: |g| g.add(""self.name":"); g.add(self.value) }
+  KeywordRestParameter     << { to_ruby: |g| g.add("**"self.name"") }
+  
+  BlockParameter    << { to_ruby: |g| g.add("&"self.name"") }
   
   ParameterAssembly << {
-    to_ruby: |g| {
-      list = []
-      list_add = Proc.new |&blk| { list.push(Proc.new(&blk)) }
-      
-      self.required.each |item| { list_add.call { g.add(item.to_s) } }
-      
-      self.optional.each |asgn| {
-        name = asgn.name
-        value = asgn.value
-        list_add.call {
-          g.add(""name"=")
-          (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
-        }
-      }
-      
-      (self.splat == true) &? (
-        list_add.call { g.add("*") }
-      ) ?? (self.splat &? ( # TODO: make prettier elsif alternative
-        list_add.call { g.add("*"self.splat"") }
-      ))
-      
-      self.post.each |item| { list_add.call { g.add(item.to_s) } }
-      
-      self.kwargs.each |asgn| {
-        name = asgn.name
-        value = asgn.value
-        list_add.call {
-          g.add(""name":")
-          (value.is_a?(SymbolLiteral) && value.value==:"*") || g.add(value)
-        }
-      }
-      
-      (self.kwrest == true) &? (
-        list_add.call { g.add("**") }
-      ) ?? (self.kwrest &? ( # TODO: make prettier elsif alternative
-        list_add.call { g.add("**"self.kwrest"") }
-      ))
-      
-      self.block && list_add.call { g.add(self.block) }
-      
-      g.add("|"); g.list(list, ", ") |proc| { proc.call }; g.add("|")
-    }
+    to_ruby: |g|
+      g.add("|"); g.list(self.all_params, ", "); g.add("|")
   }
   
   Sequence << {
@@ -381,12 +362,14 @@ CodeTools::AST << {
   
   Quest << {
     to_ruby: |g| {
+      # TODO: make this output more verbose, but more correct, and without duping the questable
       associated_questable = self.questable.dup
       associated_questable.receiver = self.receiver
       
       g.add("(")
-        g.add(self.receiver)
-          g.add(".respond_to?("self.questable.name.inspect").false?")
+        g.add("Rubinius::Type.object_respond_to?(")
+          g.add(self.receiver)
+          g.add(", "self.questable.name.inspect").false?")
         g.add(" ? ::Myco::Void : ")
         g.add(associated_questable)
       g.add(")")