myco 0.1.0.dev → 0.1.0

data/lib/myco/parser/peg_parser.rb

@@ -356,12 +356,12 @@ class CodeTools::PegParser
   # :startdoc:
 
  #%
-  attr_accessor :processor
+  attr_accessor :builder
   attr_accessor :root_node
   
-  # Generate an AST::Node of the given type (generated by the @processor)
+  # Generate an AST::Node of the given type (generated by the @builder)
   def node type, locator, *args
-    @processor.send :"process_#{type}", locator.line, *args
+    @builder.__send__ type, locator, *args
   end
   
   # Generate a Token with the given type, text, and row_col
@@ -402,7 +402,25 @@ class CodeTools::PegParser
   # TODO: rigorously test and refine
   #
   def encode_escapes str
-    str.gsub /\\(.)/ do "#{$1}" end
+    str.gsub /\\(.)/ do
+      case $1
+      when "a"; "\a" # \a  0x07  Bell or alert
+      when "b"; "\b" # \b  0x08  Backspace
+      # TODO:        # \cx       Control-x
+      # TODO:        # \C-x      Control-x
+      when "e"; "\e" # \e  0x1b  Escape
+      when "f"; "\f" # \f  0x0c  Formfeed
+      # TODO:        # \M-\C-x   Meta-Control-x
+      when "n"; "\n" # \n  0x0a  Newline
+      # TODO:        # \nnn      Octal notation, where n is a digit
+      when "r"; "\r" # \r  0x0d  Carriage return
+      when "s"; "\s" # \s  0x20  Space
+      when "t"; "\t" # \t  0x09  Tab
+      when "v"; "\v" # \v  0x0b  Vertical tab
+      # TODO:        # \xnn      Hexadecimal notation, where n is a digit
+      else; "#{$1}"
+      end
+    end
   end
   
   # Given a node,op list ([node, op, node, op, ... node]) and operator types,
@@ -424,7 +442,7 @@ class CodeTools::PegParser
         
         result = block_given? ?
           yield(n0,op,n1) :
-          node(:call, op, n0, op.sym, node(:array, n1, [n1]))
+          node(:invoke, op, n0, op.sym, node(:argass, n1, [n1]))
         input.unshift result
       else
         output.push n0
@@ -437,44 +455,6 @@ class CodeTools::PegParser
     
     input.replace output
   end
-  
-  # Given a locator and an node(:array), refactor the splat-related nodes
-  # in a copy of the original node body and return a replacement for the node.
-  #
-  def args_assemble loc, orig_node
-    list = orig_node.body.dup
-    tmp  = []
-    
-    special_type_check = Proc.new { |x|
-      case x
-      when Myco::ToolSet::AST::SplatValue;   :splat
-      when Myco::ToolSet::AST::ConcatArgs;   :argscat
-      when Myco::ToolSet::AST::PushArgs;     :argspush
-      when Myco::ToolSet::AST::BlockPass;    :block_pass
-      else; nil
-      end
-    }
-    
-    # Get the original value in the new_node
-    tmp << list.shift until list.empty? or special_type_check.call(list.first)
-    new_node = tmp.empty? ? list.shift : node(:array, loc, tmp)
-    
-    # Continue to reduce until all elements have been used
-    until list.empty?
-      arg = list.shift
-      type = special_type_check.call(arg)
-      if type == :block_pass
-        new_node = arg.tap { |n| n.arguments = new_node }
-      elsif type != nil
-        new_node = node(:argscat, loc, new_node, arg)
-      else
-        new_node = node(:argspush, loc, new_node, arg)
-      end
-    end
-    
-    new_node || orig_node
-  end
-  
 
 
   # :stopdoc:
@@ -1718,7 +1698,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # t_FLOAT = < c_num+ "." c_num+ > {token(:t_FLOAT,         text)}
+  # t_FLOAT = < "-"? c_num+ "." c_num+ > {token(:t_FLOAT,         text)}
   def _t_FLOAT
 
     _save = self.pos
@@ -1728,6 +1708,16 @@ class CodeTools::PegParser
       _save1 = self.pos
       while true # sequence
         _save2 = self.pos
+        _tmp = match_string("-")
+        unless _tmp
+          _tmp = true
+          self.pos = _save2
+        end
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save3 = self.pos
         _tmp = apply(:_c_num)
         if _tmp
           while true
@@ -1736,7 +1726,7 @@ class CodeTools::PegParser
           end
           _tmp = true
         else
-          self.pos = _save2
+          self.pos = _save3
         end
         unless _tmp
           self.pos = _save1
@@ -1747,7 +1737,7 @@ class CodeTools::PegParser
           self.pos = _save1
           break
         end
-        _save3 = self.pos
+        _save4 = self.pos
         _tmp = apply(:_c_num)
         if _tmp
           while true
@@ -1756,7 +1746,7 @@ class CodeTools::PegParser
           end
           _tmp = true
         else
-          self.pos = _save3
+          self.pos = _save4
         end
         unless _tmp
           self.pos = _save1
@@ -1783,23 +1773,42 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # t_INTEGER = < c_num+ > {token(:t_INTEGER,       text)}
+  # t_INTEGER = < "-"? c_num+ > {token(:t_INTEGER,       text)}
   def _t_INTEGER
 
     _save = self.pos
     while true # sequence
       _text_start = self.pos
+
       _save1 = self.pos
-      _tmp = apply(:_c_num)
-      if _tmp
-        while true
-          _tmp = apply(:_c_num)
-          break unless _tmp
+      while true # sequence
+        _save2 = self.pos
+        _tmp = match_string("-")
+        unless _tmp
+          _tmp = true
+          self.pos = _save2
         end
-        _tmp = true
-      else
-        self.pos = _save1
-      end
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save3 = self.pos
+        _tmp = apply(:_c_num)
+        if _tmp
+          while true
+            _tmp = apply(:_c_num)
+            break unless _tmp
+          end
+          _tmp = true
+        else
+          self.pos = _save3
+        end
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
       if _tmp
         text = get_text(_text_start)
       end
@@ -2232,6 +2241,84 @@ class CodeTools::PegParser
     return _tmp
   end
 
+  # t_OP_AND_Q = < "&?" > {token(:t_OP_AND_Q,      text)}
+  def _t_OP_AND_Q
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _tmp = match_string("&?")
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; token(:t_OP_AND_Q,      text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_t_OP_AND_Q unless _tmp
+    return _tmp
+  end
+
+  # t_OP_OR_Q = < "|?" > {token(:t_OP_OR_Q,       text)}
+  def _t_OP_OR_Q
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _tmp = match_string("|?")
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; token(:t_OP_OR_Q,       text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_t_OP_OR_Q unless _tmp
+    return _tmp
+  end
+
+  # t_OP_VOID_Q = < "??" > {token(:t_OP_VOID_Q,     text)}
+  def _t_OP_VOID_Q
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _tmp = match_string("??")
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; token(:t_OP_VOID_Q,     text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_t_OP_VOID_Q unless _tmp
+    return _tmp
+  end
+
   # t_OP_COMPARE = < ("<=>" | "=~" | "==" | "<=" | ">=" | "<" | ">") > {token(:t_OP_COMPARE,    text)}
   def _t_OP_COMPARE
 
@@ -3426,7 +3513,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # constant_list = constant:n0 (const_sep constant:n)*:nrest {node(:array, n0, [n0, *nrest])}
+  # constant_list = constant:n0 (const_sep constant:n)*:nrest {node(:arrass, n0, [n0, *nrest])}
   def _constant_list
 
     _save = self.pos
@@ -3465,7 +3552,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:array, n0, [n0, *nrest]); end
+      @result = begin; node(:arrass, n0, [n0, *nrest]); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3673,11 +3760,16 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # category_sepd_exprs = category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }
+  # category_sepd_exprs = arg_sep category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }
   def _category_sepd_exprs
 
     _save = self.pos
     while true # sequence
+      _tmp = apply(:_arg_sep)
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _tmp = apply(:_category_expr)
       n0 = @result
       unless _tmp
@@ -3724,7 +3816,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # category = category_name:n0 arg_sep category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}
+  # category = category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}
   def _category
 
     _save = self.pos
@@ -3735,11 +3827,6 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      _tmp = apply(:_arg_sep)
-      unless _tmp
-        self.pos = _save
-        break
-      end
       _save1 = self.pos
       _tmp = apply(:_category_sepd_exprs)
       @result = nil unless _tmp
@@ -4294,7 +4381,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # invoke_assignment = invoke_assignment_lhs:lhs c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {   lhs.name = :"#{lhs.name}="   orig_arguments = lhs.arguments && lhs.arguments.body || []   lhs.arguments = node(:array, rhs, [rhs, *orig_arguments])   lhs }
+  # invoke_assignment = invoke_assignment_lhs:lhs c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {   lhs.name = :"#{lhs.name}="   orig_arguments = lhs.arguments && lhs.arguments.body || []   arg_order = lhs.name==:"[]=" ? [*orig_arguments, rhs] : [rhs, *orig_arguments]   lhs.arguments = node(:argass, rhs, arg_order)   lhs }
   def _invoke_assignment
 
     _save = self.pos
@@ -4338,7 +4425,8 @@ class CodeTools::PegParser
       @result = begin; 
   lhs.name = :"#{lhs.name}="
   orig_arguments = lhs.arguments && lhs.arguments.body || []
-  lhs.arguments = node(:array, rhs, [rhs, *orig_arguments])
+  arg_order = lhs.name==:"[]=" ? [*orig_arguments, rhs] : [rhs, *orig_arguments]
+  lhs.arguments = node(:argass, rhs, arg_order)
   lhs
 ; end
       _tmp = true
@@ -4415,7 +4503,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # invoke = t_IDENTIFIER:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}
+  # invoke = t_IDENTIFIER:tn (c_spc* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}
   def _invoke
 
     _save = self.pos
@@ -4431,7 +4519,7 @@ class CodeTools::PegParser
       _save2 = self.pos
       while true # sequence
         while true
-          _tmp = apply(:_c_spc_nl)
+          _tmp = apply(:_c_spc)
           break unless _tmp
         end
         _tmp = true
@@ -4500,7 +4588,14 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # op_invoke = op_invoke_id:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}
+  # op_invoke_id = left_op_normal
+  def _op_invoke_id
+    _tmp = apply(:_left_op_normal)
+    set_failed_rule :_op_invoke_id unless _tmp
+    return _tmp
+  end
+
+  # op_invoke = op_invoke_id:tn (c_spc* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}
   def _op_invoke
 
     _save = self.pos
@@ -4516,7 +4611,7 @@ class CodeTools::PegParser
       _save2 = self.pos
       while true # sequence
         while true
-          _tmp = apply(:_c_spc_nl)
+          _tmp = apply(:_c_spc)
           break unless _tmp
         end
         _tmp = true
@@ -4585,10 +4680,57 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # op_invoke_id = left_op
-  def _op_invoke_id
-    _tmp = apply(:_left_op)
-    set_failed_rule :_op_invoke_id unless _tmp
+  # elem_invoke = lit_array:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, na, nil, :"[]", node(:argass, na, na.body), *nlist)}
+  def _elem_invoke
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_lit_array)
+      na = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+
+      _save2 = self.pos
+      while true # sequence
+        while true
+          _tmp = apply(:_c_spc_nl)
+          break unless _tmp
+        end
+        _tmp = true
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply(:_invoke_body)
+        n = @result
+        unless _tmp
+          self.pos = _save2
+        end
+        break
+      end # end sequence
+
+      @result = nil unless _tmp
+      unless _tmp
+        _tmp = true
+        self.pos = _save1
+      end
+      nlist = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; node(:invoke, na, nil, :"[]", node(:argass, na, na.body), *nlist); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_elem_invoke unless _tmp
     return _tmp
   end
 
@@ -5156,7 +5298,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # arg_list = (t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END {args_assemble(tb, node(:array, tb, []))} | t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END {args_assemble(tb, node(:array, tb, nlist))})
+  # arg_list = (t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END {node(:argass, tb, [])} | t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END {node(:argass, tb, nlist)})
   def _arg_list
 
     _save = self.pos
@@ -5180,7 +5322,7 @@ class CodeTools::PegParser
           self.pos = _save1
           break
         end
-        @result = begin; args_assemble(tb, node(:array, tb, [])); end
+        @result = begin; node(:argass, tb, []); end
         _tmp = true
         unless _tmp
           self.pos = _save1
@@ -5220,7 +5362,7 @@ class CodeTools::PegParser
           self.pos = _save2
           break
         end
-        @result = begin; args_assemble(tb, node(:array, tb, nlist)); end
+        @result = begin; node(:argass, tb, nlist); end
         _tmp = true
         unless _tmp
           self.pos = _save2
@@ -5237,7 +5379,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # lit_array = (t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END {args_assemble(tb, node(:array, tb, []))} | t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END {args_assemble(tb, node(:array, tb, nlist))})
+  # lit_array = (t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END {node(:arrass, tb, [])} | t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END {node(:arrass, tb, nlist)})
   def _lit_array
 
     _save = self.pos
@@ -5261,7 +5403,7 @@ class CodeTools::PegParser
           self.pos = _save1
           break
         end
-        @result = begin; args_assemble(tb, node(:array, tb, [])); end
+        @result = begin; node(:arrass, tb, []); end
         _tmp = true
         unless _tmp
           self.pos = _save1
@@ -5301,7 +5443,7 @@ class CodeTools::PegParser
           self.pos = _save2
           break
         end
-        @result = begin; args_assemble(tb, node(:array, tb, nlist)); end
+        @result = begin; node(:arrass, tb, nlist); end
         _tmp = true
         unless _tmp
           self.pos = _save2
@@ -5721,8 +5863,8 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # left_op = (t_OP_EXP | t_OP_MULT | t_OP_DIV | t_OP_MOD | t_OP_PLUS | t_OP_MINUS | t_OP_COMPARE | t_OP_AND | t_OP_OR)
-  def _left_op
+  # left_op_normal = (t_OP_EXP | t_OP_MULT | t_OP_DIV | t_OP_MOD | t_OP_PLUS | t_OP_MINUS | t_OP_COMPARE)
+  def _left_op_normal
 
     _save = self.pos
     while true # choice
@@ -5747,12 +5889,51 @@ class CodeTools::PegParser
       _tmp = apply(:_t_OP_COMPARE)
       break if _tmp
       self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_left_op_normal unless _tmp
+    return _tmp
+  end
+
+  # left_op_branch = (t_OP_AND | t_OP_OR | t_OP_AND_Q | t_OP_OR_Q | t_OP_VOID_Q)
+  def _left_op_branch
+
+    _save = self.pos
+    while true # choice
       _tmp = apply(:_t_OP_AND)
       break if _tmp
       self.pos = _save
       _tmp = apply(:_t_OP_OR)
       break if _tmp
       self.pos = _save
+      _tmp = apply(:_t_OP_AND_Q)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_t_OP_OR_Q)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_t_OP_VOID_Q)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_left_op_branch unless _tmp
+    return _tmp
+  end
+
+  # left_op = (left_op_normal | left_op_branch)
+  def _left_op
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_left_op_normal)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_left_op_branch)
+      break if _tmp
+      self.pos = _save
       break
     end # end choice
 
@@ -5760,7 +5941,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # left_chained_atoms = expr_atom:n0 (c_spc_nl* left_op:to c_spc_nl* expr_atom:n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_OP_EXP)   collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)   collapse(list, :t_OP_PLUS, :t_OP_MINUS)   collapse(list, :t_OP_COMPARE)   collapse(list, :t_OP_AND, :t_OP_OR) do |n0,op,n1|     type = { :t_OP_AND=>:and, :t_OP_OR=>:or }[op.type]     node(type, op, n0, n1)   end      # There should only be one resulting node left   raise "Failed to fully collapse left_chained_atoms: #{list}" \     unless list.count == 1      list.first }
+  # left_chained_atoms = expr_atom:n0 (c_spc_nl* left_op:to c_spc_nl* expr_atom:n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_OP_EXP)   collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)   collapse(list, :t_OP_PLUS, :t_OP_MINUS)   collapse(list, :t_OP_COMPARE)   collapse(list, :t_OP_AND, :t_OP_OR,                  :t_OP_AND_Q, :t_OP_OR_Q, :t_OP_VOID_Q) do |n0,op,n1|     node(:branch_op, op, op.sym, n0, n1)   end      # There should only be one resulting node left   raise "Failed to fully collapse left_chained_atoms: #{list}" \     unless list.count == 1      list.first }
   def _left_chained_atoms
 
     _save = self.pos
@@ -5879,9 +6060,9 @@ class CodeTools::PegParser
   collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)
   collapse(list, :t_OP_PLUS, :t_OP_MINUS)
   collapse(list, :t_OP_COMPARE)
-  collapse(list, :t_OP_AND, :t_OP_OR) do |n0,op,n1|
-    type = { :t_OP_AND=>:and, :t_OP_OR=>:or }[op.type]
-    node(type, op, n0, n1)
+  collapse(list, :t_OP_AND, :t_OP_OR,
+                 :t_OP_AND_Q, :t_OP_OR_Q, :t_OP_VOID_Q) do |n0,op,n1|
+    node(:branch_op, op, op.sym, n0, n1)
   end
   
   # There should only be one resulting node left
@@ -5919,21 +6100,13 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # left_chained_invocations = expr_atom_not_chained:n0 (c_spc_nl* left_invoke_op:to c_spc_nl* (invoke | op_invoke):n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_DOT, :t_QUEST) do |n0,op,n1|     op.type==:t_DOT ? (n1.receiver=n0; n1) : node(:quest, op, n0, n1)   end      # There should only be one resulting node left   raise "Failed to fully collapse left_chained_invocations: #{list}" \     unless list.count == 1      list.first }
-  def _left_chained_invocations
+  # left_chained_invocation = (c_spc_nl* left_invoke_op:to c_spc_nl* (invoke | op_invoke):n1 { [to, n1] } | c_spc* elem_invoke:n1 { [token(:t_DOT, ""), n1] })
+  def _left_chained_invocation
 
     _save = self.pos
-    while true # sequence
-      _tmp = apply(:_expr_atom_not_chained)
-      n0 = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      _save1 = self.pos
-      _ary = []
+    while true # choice
 
-      _save2 = self.pos
+      _save1 = self.pos
       while true # sequence
         while true
           _tmp = apply(:_c_spc_nl)
@@ -5941,13 +6114,13 @@ class CodeTools::PegParser
         end
         _tmp = true
         unless _tmp
-          self.pos = _save2
+          self.pos = _save1
           break
         end
         _tmp = apply(:_left_invoke_op)
         to = @result
         unless _tmp
-          self.pos = _save2
+          self.pos = _save1
           break
         end
         while true
@@ -5956,89 +6129,89 @@ class CodeTools::PegParser
         end
         _tmp = true
         unless _tmp
-          self.pos = _save2
+          self.pos = _save1
           break
         end
 
-        _save5 = self.pos
+        _save4 = self.pos
         while true # choice
           _tmp = apply(:_invoke)
           break if _tmp
-          self.pos = _save5
+          self.pos = _save4
           _tmp = apply(:_op_invoke)
           break if _tmp
-          self.pos = _save5
+          self.pos = _save4
           break
         end # end choice
 
         n1 = @result
         unless _tmp
-          self.pos = _save2
+          self.pos = _save1
           break
         end
         @result = begin;  [to, n1] ; end
         _tmp = true
         unless _tmp
-          self.pos = _save2
+          self.pos = _save1
         end
         break
       end # end sequence
 
-      if _tmp
-        _ary << @result
+      break if _tmp
+      self.pos = _save
+
+      _save5 = self.pos
+      while true # sequence
         while true
+          _tmp = apply(:_c_spc)
+          break unless _tmp
+        end
+        _tmp = true
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        _tmp = apply(:_elem_invoke)
+        n1 = @result
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        @result = begin;  [token(:t_DOT, ""), n1] ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save5
+        end
+        break
+      end # end sequence
 
-          _save6 = self.pos
-          while true # sequence
-            while true
-              _tmp = apply(:_c_spc_nl)
-              break unless _tmp
-            end
-            _tmp = true
-            unless _tmp
-              self.pos = _save6
-              break
-            end
-            _tmp = apply(:_left_invoke_op)
-            to = @result
-            unless _tmp
-              self.pos = _save6
-              break
-            end
-            while true
-              _tmp = apply(:_c_spc_nl)
-              break unless _tmp
-            end
-            _tmp = true
-            unless _tmp
-              self.pos = _save6
-              break
-            end
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
 
-            _save9 = self.pos
-            while true # choice
-              _tmp = apply(:_invoke)
-              break if _tmp
-              self.pos = _save9
-              _tmp = apply(:_op_invoke)
-              break if _tmp
-              self.pos = _save9
-              break
-            end # end choice
+    set_failed_rule :_left_chained_invocation unless _tmp
+    return _tmp
+  end
 
-            n1 = @result
-            unless _tmp
-              self.pos = _save6
-              break
-            end
-            @result = begin;  [to, n1] ; end
-            _tmp = true
-            unless _tmp
-              self.pos = _save6
-            end
-            break
-          end # end sequence
+  # left_chained_invocations = expr_atom_not_chained:n0 left_chained_invocation+:list {   list.unshift n0   list.flatten!      collapse(list, :t_DOT, :t_QUEST) do |n0,op,n1|     op.type==:t_DOT ? (n1.receiver=n0; n1) : node(:quest, op, n0, n1)   end      # There should only be one resulting node left   raise "Failed to fully collapse left_chained_invocations: #{list}" \     unless list.count == 1      list.first }
+  def _left_chained_invocations
 
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_expr_atom_not_chained)
+      n0 = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _ary = []
+      _tmp = apply(:_left_chained_invocation)
+      if _tmp
+        _ary << @result
+        while true
+          _tmp = apply(:_left_chained_invocation)
           _ary << @result if _tmp
           break unless _tmp
         end
@@ -6077,7 +6250,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # unary_operation = t_OP_NOT:to expr_atom:n0 {node(:call, to, n0, :"!", nil)}
+  # unary_operation = t_OP_NOT:to expr_atom:n0 {node(:invoke, to, n0, :"!", nil)}
   def _unary_operation
 
     _save = self.pos
@@ -6094,7 +6267,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:call, to, n0, :"!", nil); end
+      @result = begin; node(:invoke, to, n0, :"!", nil); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -6733,7 +6906,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # decorator = meme_name:ni arg_list?:na {node(:deco, ni, ni, na)}
+  # decorator = meme_name:ni arg_list?:na {node(:deco, ni, ni, (na ? node(:arrass, na, na.body) : nil))}
   def _decorator
 
     _save = self.pos
@@ -6756,7 +6929,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:deco, ni, ni, na); end
+      @result = begin; node(:deco, ni, ni, (na ? node(:arrass, na, na.body) : nil)); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -6768,7 +6941,7 @@ class CodeTools::PegParser
     return _tmp
   end
 
-  # decorators_and_meme_name = decorator:n0 (c_spc* decorator:n)*:nrest {node(:array, n0, [n0, *nrest].reverse)}
+  # decorators_and_meme_name = decorator:n0 (c_spc* decorator:n)*:nrest {node(:arrass, n0, [n0, *nrest].reverse)}
   def _decorators_and_meme_name
 
     _save = self.pos
@@ -6811,7 +6984,7 @@ class CodeTools::PegParser
         self.pos = _save
         break
       end
-      @result = begin; node(:array, n0, [n0, *nrest].reverse); end
+      @result = begin; node(:arrass, n0, [n0, *nrest].reverse); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -6983,8 +7156,8 @@ class CodeTools::PegParser
   Rules[:_t_TRUE] = rule_info("t_TRUE", "< \"true\" > {token(:t_TRUE,          text)}")
   Rules[:_t_FALSE] = rule_info("t_FALSE", "< \"false\" > {token(:t_FALSE,         text)}")
   Rules[:_t_SELF] = rule_info("t_SELF", "< \"self\" > {token(:t_SELF,          text)}")
-  Rules[:_t_FLOAT] = rule_info("t_FLOAT", "< c_num+ \".\" c_num+ > {token(:t_FLOAT,         text)}")
-  Rules[:_t_INTEGER] = rule_info("t_INTEGER", "< c_num+ > {token(:t_INTEGER,       text)}")
+  Rules[:_t_FLOAT] = rule_info("t_FLOAT", "< \"-\"? c_num+ \".\" c_num+ > {token(:t_FLOAT,         text)}")
+  Rules[:_t_INTEGER] = rule_info("t_INTEGER", "< \"-\"? c_num+ > {token(:t_INTEGER,       text)}")
   Rules[:_t_JUMP] = rule_info("t_JUMP", "< \"->\" > {token(:t_JUMP,          text)}")
   Rules[:_t_DOT] = rule_info("t_DOT", "< \".\" > {token(:t_DOT,           text)}")
   Rules[:_t_QUEST] = rule_info("t_QUEST", "< \".\" c_spc_nl* \"?\" > {token(:t_QUEST,         text)}")
@@ -7000,6 +7173,9 @@ class CodeTools::PegParser
   Rules[:_t_OP_EXP] = rule_info("t_OP_EXP", "< \"**\" > {token(:t_OP_EXP,        text)}")
   Rules[:_t_OP_AND] = rule_info("t_OP_AND", "< \"&&\" > {token(:t_OP_AND,        text)}")
   Rules[:_t_OP_OR] = rule_info("t_OP_OR", "< \"||\" > {token(:t_OP_OR,         text)}")
+  Rules[:_t_OP_AND_Q] = rule_info("t_OP_AND_Q", "< \"&?\" > {token(:t_OP_AND_Q,      text)}")
+  Rules[:_t_OP_OR_Q] = rule_info("t_OP_OR_Q", "< \"|?\" > {token(:t_OP_OR_Q,       text)}")
+  Rules[:_t_OP_VOID_Q] = rule_info("t_OP_VOID_Q", "< \"??\" > {token(:t_OP_VOID_Q,     text)}")
   Rules[:_t_OP_COMPARE] = rule_info("t_OP_COMPARE", "< (\"<=>\" | \"=~\" | \"==\" | \"<=\" | \">=\" | \"<\" | \">\") > {token(:t_OP_COMPARE,    text)}")
   Rules[:_string_norm] = rule_info("string_norm", "/[^\\\\\\\"]/")
   Rules[:_t_STRING_BODY] = rule_info("t_STRING_BODY", "< string_norm* (\"\\\\\" c_any string_norm*)* > {token(:t_STRING_BODY,   text)}")
@@ -7025,14 +7201,14 @@ class CodeTools::PegParser
   Rules[:_dyn_symstr] = rule_info("dyn_symstr", "lit_symstr:n0 dyn_string_parts:nrest {node(:dsym, n0, n0.value.to_s, nrest)}")
   Rules[:_constant] = rule_info("constant", "(constant:n0 t_SCOPE:ts t_CONSTANT:tc {node(:colon2, ts, n0, tc.sym)} | t_SCOPE:ts t_CONSTANT:tc {node(:colon3, ts, tc.sym)} | t_CONSTANT:tc {node(:const,  tc, tc.sym)})")
   Rules[:_const_sep] = rule_info("const_sep", "(c_spc_nl* t_CONST_SEP c_spc_nl*)+")
-  Rules[:_constant_list] = rule_info("constant_list", "constant:n0 (const_sep constant:n)*:nrest {node(:array, n0, [n0, *nrest])}")
+  Rules[:_constant_list] = rule_info("constant_list", "constant:n0 (const_sep constant:n)*:nrest {node(:arrass, n0, [n0, *nrest])}")
   Rules[:_id_as_symbol] = rule_info("id_as_symbol", "t_IDENTIFIER:t0 {node(:lit, t0, t0.sym)}")
   Rules[:_declobj_sepd_exprs] = rule_info("declobj_sepd_exprs", "declobj_expr:n0 (arg_sep declobj_expr:n)*:nrest arg_sep_opt { [n0, *nrest] }")
   Rules[:_declobj_expr_body] = rule_info("declobj_expr_body", "(arg_sep_opt declobj_sepd_exprs:nlist t_DECLARE_END:te {node(:block, nlist.first, nlist)} | arg_sep_opt t_DECLARE_END:te {node(:null, te)})")
   Rules[:_declobj] = rule_info("declobj", "constant_list:n0 c_spc_nl* t_DECLARE_BEGIN:t declobj_expr_body:n1 {node(:declobj, t, n0, n1)}")
   Rules[:_category_expr] = rule_info("category_expr", "declobj_expr_not_category")
-  Rules[:_category_sepd_exprs] = rule_info("category_sepd_exprs", "category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }")
-  Rules[:_category] = rule_info("category", "category_name:n0 arg_sep category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}")
+  Rules[:_category_sepd_exprs] = rule_info("category_sepd_exprs", "arg_sep category_expr:n0 (arg_sep category_expr:n)*:nrest { [n0, *nrest] }")
+  Rules[:_category] = rule_info("category", "category_name:n0 category_sepd_exprs?:nlist &(arg_sep_opt (t_CATGRY_BEGIN | t_DECLARE_END)) {node(:category, n0, n0,       (nlist ? node(:block, nlist.first, nlist) : node(:null, n0)))}")
   Rules[:_copen] = rule_info("copen", "constant:n0 c_spc_nl* t_REOPEN:tb c_spc_nl* t_DECLARE_BEGIN declobj_expr_body:n1 {node(:copen, tb, n0, n1)}")
   Rules[:_cdefn] = rule_info("cdefn", "constant:n0 c_spc_nl* t_DEFINE:t c_spc_nl* declobj:n1 {node(:cdefn, t, n0, n1)}")
   Rules[:_t_DECLSTR_BEGIN] = rule_info("t_DECLSTR_BEGIN", "< /[^\\s{:,<][^\\s]+/ > {      \# Table of replacement characters to use when calculating   \# the ending delimiter from the starting delimiter.   \# Directional characters are replaced with their opposite.   @declstr_replace_tbl ||= %w{     < > ( ) { } [ ]   }      \# Calculate the ending delimiter to look for and store it   @declstr_destrlim = text \\     .split(/(?<=[^a-zA-Z])|(?=[^a-zA-Z])/)     .map { |str|       idx = @declstr_replace_tbl.find_index(str)       idx.nil? ? str :          (idx.odd? ? @declstr_replace_tbl[idx-1] : @declstr_replace_tbl[idx+1])     }     .reverse     .join ''      token(:t_DECLSTR_BEGIN, text) }")
@@ -7046,11 +7222,12 @@ class CodeTools::PegParser
   Rules[:_assign_rhs] = rule_info("assign_rhs", "arg_expr")
   Rules[:_local_assignment] = rule_info("local_assignment", "t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {node(:lasgn, to, ti.sym, rhs)}")
   Rules[:_invoke_assignment_lhs] = rule_info("invoke_assignment_lhs", "(left_chained_invocations | invoke)")
-  Rules[:_invoke_assignment] = rule_info("invoke_assignment", "invoke_assignment_lhs:lhs c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {   lhs.name = :\"\#{lhs.name}=\"   orig_arguments = lhs.arguments && lhs.arguments.body || []   lhs.arguments = node(:array, rhs, [rhs, *orig_arguments])   lhs }")
+  Rules[:_invoke_assignment] = rule_info("invoke_assignment", "invoke_assignment_lhs:lhs c_spc_nl* t_ASSIGN:to c_spc_nl* assign_rhs:rhs {   lhs.name = :\"\#{lhs.name}=\"   orig_arguments = lhs.arguments && lhs.arguments.body || []   arg_order = lhs.name==:\"[]=\" ? [*orig_arguments, rhs] : [rhs, *orig_arguments]   lhs.arguments = node(:argass, rhs, arg_order)   lhs }")
   Rules[:_invoke_body] = rule_info("invoke_body", "(c_spc_nl* param_list:n)?:np c_spc_nl* meme_enclosed_expr_body:nb { [np, nb] }")
-  Rules[:_invoke] = rule_info("invoke", "t_IDENTIFIER:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}")
-  Rules[:_op_invoke] = rule_info("op_invoke", "op_invoke_id:tn (c_spc_nl* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}")
-  Rules[:_op_invoke_id] = rule_info("op_invoke_id", "left_op")
+  Rules[:_invoke] = rule_info("invoke", "t_IDENTIFIER:tn (c_spc* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}")
+  Rules[:_op_invoke_id] = rule_info("op_invoke_id", "left_op_normal")
+  Rules[:_op_invoke] = rule_info("op_invoke", "op_invoke_id:tn (c_spc* arg_list:na)?:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, tn, nil, tn.sym, na, *nlist)}")
+  Rules[:_elem_invoke] = rule_info("elem_invoke", "lit_array:na (c_spc_nl* invoke_body:n)?:nlist {node(:invoke, na, nil, :\"[]\", node(:argass, na, na.body), *nlist)}")
   Rules[:_arg_sep] = rule_info("arg_sep", "(c_spc* t_ARG_SEP c_spc*)+")
   Rules[:_arg_sep_opt] = rule_info("arg_sep_opt", "(c_spc | t_ARG_SEP)*")
   Rules[:_in_arg_normal] = rule_info("in_arg_normal", "(in_arg_splat | arg_expr:n0 !in_arg_kwarg_mark { n0 })")
@@ -7061,17 +7238,20 @@ class CodeTools::PegParser
   Rules[:_in_arg_splat] = rule_info("in_arg_splat", "t_OP_MULT:to expr_atom:n0 {node(:splat, to, n0)}")
   Rules[:_in_arg_block] = rule_info("in_arg_block", "t_OP_TOPROC:to expr_atom:n0 {node(:block_pass, to, nil, n0)}")
   Rules[:_in_arg_list] = rule_info("in_arg_list", "(in_arg_normals:n0 arg_sep in_arg_kwargs:n1 arg_sep in_arg_block:n2 { [*n0,n1,n2] } | in_arg_normals:n0 arg_sep in_arg_kwargs:n1 { [*n0,n1] } | in_arg_normals:n0 arg_sep in_arg_block:n1 { [*n0,n1] } | in_arg_kwargs:n0 arg_sep in_arg_block:n1 { [n0, n1] } | in_arg_normals:n0 { [*n0] } | in_arg_kwargs:n0 { [n0] } | in_arg_block:n0 { [n0] })")
-  Rules[:_arg_list] = rule_info("arg_list", "(t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END {args_assemble(tb, node(:array, tb, []))} | t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END {args_assemble(tb, node(:array, tb, nlist))})")
-  Rules[:_lit_array] = rule_info("lit_array", "(t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END {args_assemble(tb, node(:array, tb, []))} | t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END {args_assemble(tb, node(:array, tb, nlist))})")
+  Rules[:_arg_list] = rule_info("arg_list", "(t_ARGS_BEGIN:tb arg_sep_opt t_ARGS_END {node(:argass, tb, [])} | t_ARGS_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARGS_END {node(:argass, tb, nlist)})")
+  Rules[:_lit_array] = rule_info("lit_array", "(t_ARRAY_BEGIN:tb arg_sep_opt t_ARRAY_END {node(:arrass, tb, [])} | t_ARRAY_BEGIN:tb arg_sep_opt in_arg_list:nlist arg_sep_opt t_ARRAY_END {node(:arrass, tb, nlist)})")
   Rules[:_param] = rule_info("param", "(t_IDENTIFIER:ti c_spc_nl* t_ASSIGN:to c_spc_nl* arg_expr:nv { [:optional, node(:lasgn, ti, ti.sym, nv)] } | t_IDENTIFIER:ti c_spc_nl* t_MEME_MARK:to c_spc_nl* arg_expr?:nv { [:kwargs, node(:lasgn, ti, ti.sym, (nv || node(:lit, to, :*)))] } | t_OP_EXP c_spc_nl* t_IDENTIFIER:ti { [:kwrest,   ti.sym] } | t_OP_MULT c_spc_nl* t_IDENTIFIER:ti { [:rest,     ti.sym] } | t_OP_TOPROC c_spc_nl* t_IDENTIFIER:ti { [:block,    ti.sym] } | t_IDENTIFIER:ti { [:required, ti.sym] })")
   Rules[:_param_sepd] = rule_info("param_sepd", "arg_sep param:n0 { n0 }")
   Rules[:_param_sepds] = rule_info("param_sepds", "param:n0 (arg_sep param:n)*:nrest arg_sep_opt { [n0, *nrest] }")
   Rules[:_param_list] = rule_info("param_list", "(t_PARAMS_BEGIN:tb t_PARAMS_END { node(:args, tb, nil, nil, nil, nil, nil, nil, nil) } | t_PARAMS_BEGIN:tb param_sepds:plist t_PARAMS_END {       required, optional, rest, kwargs, kwrest, block = 6.times.map { [] }              required << plist.shift[1] while plist[0] && plist[0][0] == :required       optional << plist.shift[1] while plist[0] && plist[0][0] == :optional       rest     << plist.shift[1] while plist[0] && plist[0][0] == :rest       kwargs   << plist.shift[1] while plist[0] && plist[0][0] == :kwargs       kwrest   << plist.shift[1] while plist[0] && plist[0][0] == :kwrest       block    << plist.shift[1] while plist[0] && plist[0][0] == :block              required = required       optional = optional.empty? ? nil : node(:block, tb, optional)       rest     = rest.first       post     = nil       kwargs   = kwargs.empty?   ? nil : node(:block, tb, kwargs)       kwrest   = kwrest.first       block    = block.first              node(:args, tb, required, optional, rest, post, kwargs, kwrest, block)     })")
-  Rules[:_left_op] = rule_info("left_op", "(t_OP_EXP | t_OP_MULT | t_OP_DIV | t_OP_MOD | t_OP_PLUS | t_OP_MINUS | t_OP_COMPARE | t_OP_AND | t_OP_OR)")
-  Rules[:_left_chained_atoms] = rule_info("left_chained_atoms", "expr_atom:n0 (c_spc_nl* left_op:to c_spc_nl* expr_atom:n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_OP_EXP)   collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)   collapse(list, :t_OP_PLUS, :t_OP_MINUS)   collapse(list, :t_OP_COMPARE)   collapse(list, :t_OP_AND, :t_OP_OR) do |n0,op,n1|     type = { :t_OP_AND=>:and, :t_OP_OR=>:or }[op.type]     node(type, op, n0, n1)   end      \# There should only be one resulting node left   raise \"Failed to fully collapse left_chained_atoms: \#{list}\" \\     unless list.count == 1      list.first }")
+  Rules[:_left_op_normal] = rule_info("left_op_normal", "(t_OP_EXP | t_OP_MULT | t_OP_DIV | t_OP_MOD | t_OP_PLUS | t_OP_MINUS | t_OP_COMPARE)")
+  Rules[:_left_op_branch] = rule_info("left_op_branch", "(t_OP_AND | t_OP_OR | t_OP_AND_Q | t_OP_OR_Q | t_OP_VOID_Q)")
+  Rules[:_left_op] = rule_info("left_op", "(left_op_normal | left_op_branch)")
+  Rules[:_left_chained_atoms] = rule_info("left_chained_atoms", "expr_atom:n0 (c_spc_nl* left_op:to c_spc_nl* expr_atom:n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_OP_EXP)   collapse(list, :t_OP_MULT, :t_OP_DIV, :t_OP_MOD)   collapse(list, :t_OP_PLUS, :t_OP_MINUS)   collapse(list, :t_OP_COMPARE)   collapse(list, :t_OP_AND, :t_OP_OR,                  :t_OP_AND_Q, :t_OP_OR_Q, :t_OP_VOID_Q) do |n0,op,n1|     node(:branch_op, op, op.sym, n0, n1)   end      \# There should only be one resulting node left   raise \"Failed to fully collapse left_chained_atoms: \#{list}\" \\     unless list.count == 1      list.first }")
   Rules[:_left_invoke_op] = rule_info("left_invoke_op", "(t_QUEST | t_DOT)")
-  Rules[:_left_chained_invocations] = rule_info("left_chained_invocations", "expr_atom_not_chained:n0 (c_spc_nl* left_invoke_op:to c_spc_nl* (invoke | op_invoke):n1 { [to, n1] })+:list {   list.unshift n0   list.flatten!      collapse(list, :t_DOT, :t_QUEST) do |n0,op,n1|     op.type==:t_DOT ? (n1.receiver=n0; n1) : node(:quest, op, n0, n1)   end      \# There should only be one resulting node left   raise \"Failed to fully collapse left_chained_invocations: \#{list}\" \\     unless list.count == 1      list.first }")
-  Rules[:_unary_operation] = rule_info("unary_operation", "t_OP_NOT:to expr_atom:n0 {node(:call, to, n0, :\"!\", nil)}")
+  Rules[:_left_chained_invocation] = rule_info("left_chained_invocation", "(c_spc_nl* left_invoke_op:to c_spc_nl* (invoke | op_invoke):n1 { [to, n1] } | c_spc* elem_invoke:n1 { [token(:t_DOT, \"\"), n1] })")
+  Rules[:_left_chained_invocations] = rule_info("left_chained_invocations", "expr_atom_not_chained:n0 left_chained_invocation+:list {   list.unshift n0   list.flatten!      collapse(list, :t_DOT, :t_QUEST) do |n0,op,n1|     op.type==:t_DOT ? (n1.receiver=n0; n1) : node(:quest, op, n0, n1)   end      \# There should only be one resulting node left   raise \"Failed to fully collapse left_chained_invocations: \#{list}\" \\     unless list.count == 1      list.first }")
+  Rules[:_unary_operation] = rule_info("unary_operation", "t_OP_NOT:to expr_atom:n0 {node(:invoke, to, n0, :\"!\", nil)}")
   Rules[:_t_inln_sep] = rule_info("t_inln_sep", "!t_ARG_SEP t_EXPR_SEP")
   Rules[:_inln_sep] = rule_info("inln_sep", "(c_spc* t_inln_sep c_spc*)+")
   Rules[:_inln_sep_opt] = rule_info("inln_sep_opt", "(c_spc | t_inln_sep)*")
@@ -7087,8 +7267,8 @@ class CodeTools::PegParser
   Rules[:_meme_either_body] = rule_info("meme_either_body", "(meme_enclosed_expr_body | meme_inline_expr_body)")
   Rules[:_cmeme] = rule_info("cmeme", "constant:n0 c_spc* t_MEME_MARK:tm c_spc_nl* meme_inline_expr_body:n1 {node(:cdecl, tm, n0, n1)}")
   Rules[:_meme_name] = rule_info("meme_name", "(id_as_symbol | lit_string_as_symbol)")
-  Rules[:_decorator] = rule_info("decorator", "meme_name:ni arg_list?:na {node(:deco, ni, ni, na)}")
-  Rules[:_decorators_and_meme_name] = rule_info("decorators_and_meme_name", "decorator:n0 (c_spc* decorator:n)*:nrest {node(:array, n0, [n0, *nrest].reverse)}")
+  Rules[:_decorator] = rule_info("decorator", "meme_name:ni arg_list?:na {node(:deco, ni, ni, (na ? node(:arrass, na, na.body) : nil))}")
+  Rules[:_decorators_and_meme_name] = rule_info("decorators_and_meme_name", "decorator:n0 (c_spc* decorator:n)*:nrest {node(:arrass, n0, [n0, *nrest].reverse)}")
   Rules[:_meme] = rule_info("meme", "(decorators_and_meme_name:nd c_spc* t_MEME_MARK:tm (c_spc_nl* param_list:n)?:np c_spc_nl* meme_either_body:nb {node(:meme, tm, nd.body.shift.name, nd, np,  nb)} | decorators_and_meme_name:nd {node(:meme, tm, nd.body.shift.name, nd, nil, nil)})")
   # :startdoc:
 end