ruby_parser 3.12.0 → 3.13.0

data/lib/{ruby19_parser.y → ruby26_parser.y}

@@ -1,6 +1,6 @@
 # -*- racc -*-
 
-class Ruby19Parser
+class Ruby26Parser
 
 token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
@@ -17,8 +17,11 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       tPLUS tMINUS tLT tGT tPIPE tBANG tCARET tLCURLY tRCURLY
       tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG
       tWORDS_BEG tQWORDS_BEG tSTRING_DBEG tSTRING_DVAR tSTRING_END
-      tSTRING tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAST_TOKEN
-      tLAMBDA tLAMBEG
+      tSTRING tSYMBOL tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA
+      tLAMBEG tDSTAR tCHAR tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DEND tUBANG
+      tRATIONAL tIMAGINARY
+      tLABEL_END
+       tLONELY
 
 prechigh
   right    tBANG tTILDE tUPLUS
@@ -69,21 +72,51 @@ rule
                 | error top_stmt
 
         top_stmt: stmt
+                    {
+                      result = val[0]
+
+                      # TODO: remove once I have more confidence this is fixed
+                      # result.each_of_type :call_args do |s|
+                      #   debug20 666, s, result
+                      # end
+                    }
                 | klBEGIN
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 1
                         yyerror "BEGIN in method"
                       end
                       self.env.extend
                     }
-                    tLCURLY top_compstmt tRCURLY
+                    begin_block
+                    {
+                      _, _, block = val
+                      result = block
+                    }
+
+     begin_block: tLCURLY top_compstmt tRCURLY
+                    {
+                      _, stmt, _ = val
+                      result = new_iter s(:preexe), 0, stmt
+                    }
+
+        bodystmt: compstmt opt_rescue k_else
                     {
-                      result = new_iter s(:preexe), nil, val[3]
+                      res = _values[-2]
+                      yyerror "else without rescue is useless" unless res
                     }
+                    compstmt
+                    opt_ensure
+                    {
+                      body, resc, _, _, els, ens = val
 
-        bodystmt: compstmt opt_rescue opt_else opt_ensure
+                      result = new_body [body, resc, els, ens]
+                    }
+                | compstmt opt_rescue opt_ensure
                     {
-                      result = new_body val
+                      body, resc, ens = val
+
+                      result = new_body [body, resc, nil, ens]
                     }
 
         compstmt: stmts opt_terms
@@ -92,14 +125,30 @@ rule
                     }
 
            stmts: none
-                | stmt
-                | stmts terms stmt
+                | stmt_or_begin # TODO: newline_node ?
+                | stmts terms stmt_or_begin
                     {
                       result = self.block_append val[0], val[2]
                     }
                 | error stmt
                     {
                       result = val[1]
+                      debug20 2, val, result
+                    }
+
+   stmt_or_begin: stmt
+                | klBEGIN
+                    {
+                      if (self.in_def || self.in_single > 0) then
+                        debug20 1
+                        yyerror "BEGIN in method"
+                      end
+                      self.env.extend
+                    }
+                    begin_block
+                    {
+                      _, _, stmt = val
+                      result = stmt
                     }
 
             stmt: kALIAS fitem
@@ -145,11 +194,13 @@ rule
                     }
                 | stmt kRESCUE_MOD stmt
                     {
-                      result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
+                      body, _, resbody = val
+                      result = new_rescue body, new_resbody(s(:array), resbody)
                     }
                 | klEND tLCURLY compstmt tRCURLY
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 3
                         yyerror "END in method; use at_exit"
                       end
                       result = new_iter s(:postexe), 0, val[2]
@@ -159,56 +210,75 @@ rule
                     {
                       result = new_masgn val[0], val[2], :wrap
                     }
-                | var_lhs tOP_ASGN command_call
+                | lhs tEQL mrhs
+                    {
+                      result = new_assign val[0], s(:svalue, val[2])
+                    }
+                | mlhs tEQL mrhs_arg
+                    {
+                      result = new_masgn val[0], val[2]
+                    }
+                | expr
+
+    command_asgn: lhs tEQL command_rhs
+                    {
+                      result = new_assign val[0], val[2]
+                    }
+                # | lhs tEQL command_asgn
+                #     {
+                #       result = new_assign val[0], val[2]
+                #     }
+                | var_lhs tOP_ASGN command_rhs
                     {
                       result = new_op_asgn val
                     }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_call
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
-                | primary_value tDOT tIDENTIFIER tOP_ASGN command_call
+                | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
+                      if val[1] == '&.'
+                        result.sexp_type = :safe_op_asgn
+                      end
+                      result.line = val[0].line
                     }
-                | primary_value tDOT tCONSTANT tOP_ASGN command_call
+                | primary_value call_op tCONSTANT tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
+                      if val[1] == '&.'
+                        result.sexp_type = :safe_op_asgn
+                      end
+                      result.line = val[0].line
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
+                      debug20 4, val, result
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
+                      debug20 5, val, result
                     }
-                | backref tOP_ASGN command_call
+                | backref tOP_ASGN command_rhs
                     {
                       self.backref_assign_error val[0]
                     }
-                | lhs tEQL mrhs
-                    {
-                      result = new_assign val[0], s(:svalue, val[2])
-                    }
-                | mlhs tEQL arg_value
-                    {
-                      result = new_masgn val[0], val[2], :wrap
-                    }
-                | mlhs tEQL mrhs
-                    {
-                      result = new_masgn val[0], val[2]
-                    }
-                | expr
 
-    command_asgn: lhs tEQL command_call
+     command_rhs: command_call                =tOP_ASGN
                     {
-                      result = new_assign val[0], val[2]
+                      expr, = val
+                      result = value_expr expr
                     }
-                | lhs tEQL command_asgn
+                | command_call kRESCUE_MOD stmt
                     {
-                      result = new_assign val[0], val[2]
+                      expr, _, resbody = val
+                      expr = value_expr expr
+                      result = new_rescue(expr, new_resbody(s(:array), resbody))
                     }
+                | command_asgn
 
             expr: command_call
                 | expr kAND expr
@@ -234,43 +304,54 @@ rule
                       result = value_expr(val[0])
                     }
 
+   expr_value_do:   {
+                      lexer.cond.push true
+                    }
+                    expr_value do
+                    {
+                      lexer.cond.pop
+                    }
+                    {
+                      _, expr, _, _ = val
+                      result = expr
+                    }
+
     command_call: command
                 | block_command
 
    block_command: block_call
-                | block_call tDOT operation2 command_args # TODO: dot_or_colon
-                    {
-                      result = new_call val[0], val[2].to_sym, val[3]
-                    }
-                | block_call tCOLON2 operation2 command_args
+                | block_call call_op2 operation2 command_args
                     {
                       result = new_call val[0], val[2].to_sym, val[3]
                     }
 
  cmd_brace_block: tLBRACE_ARG
                     {
-                      self.env.extend(:dynamic)
+                      # self.env.extend(:dynamic)
                       result = self.lexer.lineno
                     }
-                    opt_block_param
+                    brace_body tRCURLY
                     {
-                      result = nil # self.env.dynamic.keys
+                      _, line, body, _ = val
+
+                      result = body
+                      result.line = line
+
+                      # self.env.unextend
                     }
-                    compstmt tRCURLY
-                    {
-                      result = new_iter nil, val[2], val[4]
-                      result.line = val[1]
 
-                      self.env.unextend
+           fcall: operation
+                    {
+                      result = new_call nil, val[0].to_sym
                     }
 
-         command: operation command_args =tLOWEST
+         command: fcall command_args =tLOWEST
                     {
-                      result = new_call nil, val[0].to_sym, val[1]
+                      result = val[0].concat val[1].sexp_body # REFACTOR pattern
                     }
-                | operation command_args cmd_brace_block
+                | fcall command_args cmd_brace_block
                     {
-                      result = new_call nil, val[0].to_sym, val[1]
+                      result = val[0].concat val[1].sexp_body
                       if val[2] then
                         block_dup_check result, val[2]
 
@@ -278,14 +359,14 @@ rule
                         result.insert 1, operation
                       end
                     }
-                | primary_value tDOT operation2 command_args =tLOWEST
+                | primary_value call_op operation2 command_args =tLOWEST
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      result = new_call val[0], val[2].to_sym, val[3], val[1]
                     }
-                | primary_value tDOT operation2 command_args cmd_brace_block
+                | primary_value call_op operation2 command_args cmd_brace_block
                     {
                       recv, _, msg, args, block = val
-                      call = new_call recv, msg.to_sym, args
+                      call = new_call recv, msg.to_sym, args, val[1]
 
                       block_dup_check call, block
 
@@ -314,7 +395,7 @@ rule
                     {
                       result = new_yield val[1]
                     }
-                | kRETURN call_args
+                | k_return call_args
                     {
                       line = val[0].last
                       result = s(:return, ret_args(val[1])).line(line)
@@ -356,9 +437,11 @@ rule
                     }
                 | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
                     {
-                      ary = list_append val[0], s(:splat, val[2])
-                      ary.concat val[4].sexp_body
-                      result = s(:masgn, ary)
+                      ary1, _, splat, _, ary2 = val
+
+                      result = list_append ary1, s(:splat, splat)
+                      result.concat ary2.sexp_body
+                      result = s(:masgn, result)
                     }
                 | mlhs_head tSTAR
                     {
@@ -386,9 +469,7 @@ rule
                     }
                 | tSTAR tCOMMA mlhs_post
                     {
-                      ary = s(:array, s(:splat))
-                      ary.concat val[2].sexp_body
-                      result = s(:masgn, ary)
+                      result = s(:masgn, s(:array, s(:splat), *val[2].sexp_body))
                     }
 
        mlhs_item: mlhs_node
@@ -427,21 +508,22 @@ rule
                     {
                       result = self.aryset val[0], val[2]
                     }
-                | primary_value tDOT tIDENTIFIER
+                | primary_value call_op tIDENTIFIER
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      result = new_attrasgn val[0], val[2], val[1]
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
                       result = s(:attrasgn, val[0], :"#{val[2]}=")
                     }
-                | primary_value tDOT tCONSTANT
+                | primary_value call_op tCONSTANT
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      result = new_attrasgn val[0], val[2], val[1]
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 7
                         yyerror "dynamic constant assignment"
                       end
 
@@ -450,6 +532,7 @@ rule
                 | tCOLON3 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 8
                         yyerror "dynamic constant assignment"
                       end
 
@@ -467,26 +550,28 @@ rule
                 | keyword_variable
                     {
                       result = self.assignable val[0]
+                      debug20 9, val, result
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket
                     {
                       result = self.aryset val[0], val[2]
                     }
-                | primary_value tDOT tIDENTIFIER
+                | primary_value call_op tIDENTIFIER # REFACTOR
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      result = new_attrasgn val[0], val[2], val[1]
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
                       result = s(:attrasgn, val[0], :"#{val[2]}=")
                     }
-                | primary_value tDOT tCONSTANT
+                | primary_value call_op tCONSTANT # REFACTOR?
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      result = new_attrasgn val[0], val[2], val[1]
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 10
                         yyerror "dynamic constant assignment"
                       end
 
@@ -495,6 +580,7 @@ rule
                 | tCOLON3 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
+                        debug20 11
                         yyerror "dynamic constant assignment"
                       end
 
@@ -533,13 +619,17 @@ rule
 
                 | reswords
                     {
+                      (sym, _line), = val
                       lexer.lex_state = :expr_end
-                      result = val[0]
+                      result = sym
                     }
 
             fsym: fname | symbol
 
-           fitem: fsym { result = s(:lit, val[0].to_sym) }
+           fitem: fsym
+                    {
+                      result = s(:lit, val[0].to_sym)
+                    }
                 | dsym
 
       undef_list: fitem
@@ -556,11 +646,12 @@ rule
                       result = new_undef val[0], val[3]
                     }
 
-                op: tPIPE    | tCARET  | tAMPER2  | tCMP  | tEQ     | tEQQ
-                |   tMATCH   | tNMATCH | tGT      | tGEQ  | tLT     | tLEQ
-                |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS  | tSTAR2
-                |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tBANG   | tTILDE
+                op: tPIPE    | tCARET  | tAMPER2  | tCMP  | tEQ    | tEQQ
+                |   tMATCH   | tNMATCH | tGT      | tGEQ  | tLT    | tLEQ
+                |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS | tSTAR2
+                |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tDSTAR | tBANG   | tTILDE
                 |   tUPLUS   | tUMINUS | tAREF    | tASET | tBACK_REF2
+                |   tUBANG
 
         reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
                 | kALIAS    | kAND      | kBEGIN        | kBREAK  | kCASE
@@ -572,51 +663,46 @@ rule
                 | kWHEN     | kYIELD    | kIF           | kUNLESS | kWHILE
                 | kUNTIL
 
-             arg: lhs tEQL arg
+             arg: lhs tEQL arg_rhs
                     {
                       result = new_assign val[0], val[2]
                     }
-                | lhs tEQL arg kRESCUE_MOD arg
-                    {
-                      result = new_assign val[0], s(:rescue, val[2], new_resbody(s(:array), val[4]))
-                    }
-                | var_lhs tOP_ASGN arg
-                    {
-                      result = new_op_asgn val
-                    }
-                | var_lhs tOP_ASGN arg kRESCUE_MOD arg
+                | var_lhs tOP_ASGN arg_rhs
                     {
                       result = new_op_asgn val
-                      result = s(:rescue, result, new_resbody(s(:array), val[4]))
                     }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
                     {
                       val[2].sexp_type = :arglist if val[2]
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
-                | primary_value tDOT tIDENTIFIER tOP_ASGN arg
+                | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                     {
-                      result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
+                      result = new_op_asgn2 val
                     }
-                | primary_value tDOT tCONSTANT tOP_ASGN arg
+                | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
                     {
-                      result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
+                      result = new_op_asgn2 val
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      yyerror "constant re-assignment"
+                      # TODO: assignment
+                      raise "not yet: %p" % [val]
                     }
-                | tCOLON3 tCONSTANT tOP_ASGN arg
+                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      yyerror "constant re-assignment"
+                      # TODO: assignment
+                      raise "not yet: %p" % [val]
                     }
-                | backref tOP_ASGN arg
+                | backref tOP_ASGN arg_rhs
                     {
-                      self.backref_assign_error val[0]
+                      # TODO: lhs = var_field val[0]
+                      asgn = new_op_asgn val
+                      result = self.backref_assign_error asgn
                     }
                 | arg tDOT2 arg
                     {
@@ -636,6 +722,18 @@ rule
                         result = s(:dot3, v1, v2)
                       end
                     }
+                | arg tDOT2
+                    {
+                      v1, v2 = val[0], nil
+
+                      result = s(:dot2, v1, v2)
+                    }
+                | arg tDOT3
+                    {
+                      v1, v2 = val[0], nil
+
+                      result = s(:dot3, v1, v2)
+                    }
                 | arg tPLUS arg
                     {
                       result = new_call val[0], :+, argl(val[2])
@@ -644,7 +742,7 @@ rule
                     {
                       result = new_call val[0], :-, argl(val[2])
                     }
-                | arg tSTAR2 arg
+                | arg tSTAR2 arg # TODO: rename
                     {
                       result = new_call val[0], :*, argl(val[2])
                     }
@@ -660,11 +758,7 @@ rule
                     {
                       result = new_call val[0], :**, argl(val[2])
                     }
-                | tUMINUS_NUM tINTEGER tPOW arg
-                    {
-                      result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
-                    }
-                | tUMINUS_NUM tFLOAT tPOW arg
+                | tUMINUS_NUM simple_numeric tPOW arg
                     {
                       result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
                     }
@@ -692,22 +786,7 @@ rule
                     {
                       result = new_call val[0], :"<=>", argl(val[2])
                     }
-                | arg tGT arg
-                    {
-                      result = new_call val[0], :">", argl(val[2])
-                    }
-                | arg tGEQ arg
-                    {
-                      result = new_call val[0], :">=", argl(val[2])
-                    }
-                | arg tLT arg
-                    {
-                      result = new_call val[0], :"<", argl(val[2])
-                    }
-                | arg tLEQ arg
-                    {
-                      result = new_call val[0], :"<=", argl(val[2])
-                    }
+                | rel_expr                      =tCMP
                 | arg tEQ arg
                     {
                       result = new_call val[0], :"==", argl(val[2])
@@ -734,8 +813,7 @@ rule
                     }
                 | tTILDE arg
                     {
-                      val[2] = value_expr val[2]
-                      result = new_call val[1], :"~"
+                      result = new_call value_expr(val[1]), :"~"
                     }
                 | arg tLSHFT arg
                     {
@@ -767,6 +845,23 @@ rule
                     }
                 | primary
 
+           relop: tGT
+                | tLT
+                | tGEQ
+                | tLEQ
+
+        rel_expr: arg      relop arg                    =tGT
+                    {
+                      lhs, op, rhs = val
+                      result = new_call lhs, op.to_sym, argl(rhs)
+                    }
+                | rel_expr relop arg                    =tGT
+                    {
+                      lhs, op, rhs = val
+                      warn "comparison '%s' after comparison", op
+                      result = new_call lhs, op.to_sym, argl(rhs)
+                    }
+
        arg_value: arg
                     {
                       result = value_expr(val[0])
@@ -775,15 +870,24 @@ rule
        aref_args: none
                 | args trailer
                     {
-                      result = val[0]
+                      result = args [val[0]]
                     }
                 | args tCOMMA assocs trailer
                     {
-                      result = val[0] << s(:hash, *val[2].values)
+                      result = args [val[0], array_to_hash(val[2])]
                     }
                 | assocs trailer
                     {
-                      result = s(:array, s(:hash, *val[0].values))
+                      result = args [array_to_hash(val[0])]
+                    }
+
+         arg_rhs: arg                   =tOP_ASGN
+                | arg kRESCUE_MOD arg
+                    {
+                      body, _, resbody = val
+                      body    = value_expr body
+                      resbody = remove_begin resbody
+                      result  = new_rescue(body, new_resbody(s(:array), resbody))
                     }
 
       paren_args: tLPAREN2 opt_call_args rparen
@@ -804,45 +908,48 @@ rule
                     }
                 | args tCOMMA
                     {
-                      result = val[0]
+                      result = args val
                     }
                 | args tCOMMA assocs tCOMMA
                     {
-                      result = val[0] << s(:hash, *val[2].sexp_body) # TODO: self.args
+                      result = args [val[0], array_to_hash(val[2])]
                     }
                 | assocs tCOMMA
                     {
-                      result = s(:hash, *val[0].values)
+                      result = args [array_to_hash(val[0])]
                     }
 
        call_args: command
                     {
                       warning "parenthesize argument(s) for future version"
-                      result = s(:array, val[0])
+                      result = call_args val
                     }
                 | args opt_block_arg
                     {
+                      result = call_args val
                       result = self.arg_blk_pass val[0], val[1]
                     }
                 | assocs opt_block_arg
                     {
-                      result = s(:array, s(:hash, *val[0].values))
+                      result = call_args [array_to_hash(val[0])]
                       result = self.arg_blk_pass result, val[1]
                     }
                 | args tCOMMA assocs opt_block_arg
                     {
-                      result = val[0] << s(:hash, *val[2].values)
+                      result = call_args [val[0], array_to_hash(val[2])]
                       result = self.arg_blk_pass result, val[3]
                     }
                 | block_arg
+                    {
+                      result = call_args val
+                    }
 
     command_args:   {
-                      result = lexer.cmdarg.stack.dup # TODO: smell?
-                      lexer.cmdarg.push true
+                      result = lexer.cmdarg.store true
                     }
                       call_args
                     {
-                      lexer.cmdarg.stack.replace val[0]
+                      lexer.cmdarg.restore val[0]
                       result = val[1]
                     }
 
@@ -874,6 +981,15 @@ rule
                       result = self.list_append val[0], s(:splat, val[3])
                     }
 
+        mrhs_arg: mrhs
+                    {
+                      result = new_masgn_arg val[0]
+                    }
+                | arg_value
+                    {
+                      result = new_masgn_arg val[0], :wrap
+                    }
+
             mrhs: args tCOMMA arg_value
                     {
                       result = val[0] << val[2]
@@ -893,18 +1009,24 @@ rule
                 | regexp
                 | words
                 | qwords
+                | symbols
+                | qsymbols
                 | var_ref
                 | backref
                 | tFID
                     {
                       result = new_call nil, val[0].to_sym
                     }
-                | kBEGIN
+                | k_begin
                     {
                       result = self.lexer.lineno
+                      # TODO:
+                      # $<val>1 = cmdarg_stack;
+                      # CMDARG_SET(0);
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
+                      # TODO: CMDARG_SET($<val>1);
                       unless val[2] then
                         result = s(:nil)
                       else
@@ -913,14 +1035,27 @@ rule
 
                       result.line = val[1]
                     }
-                | tLPAREN_ARG expr
+                | tLPAREN_ARG rparen
+                    {
+                      # TODO: lex_state = :expr_endarg in between
+                      debug20 13, val, result
+                    }
+                | tLPAREN_ARG
+                    {
+                      result = lexer.cmdarg.store false
+                      # result = self.lexer.cmdarg.stack.dup
+                      # lexer.cmdarg.stack.replace [false] # TODO add api for these
+                    }
+                    stmt
                     {
                       lexer.lex_state = :expr_endarg
                     }
                     rparen
                     {
+                      _, cmdarg, stmt, _, _, = val
                       warning "(...) interpreted as grouped expression"
-                      result = val[1]
+                      lexer.cmdarg.restore cmdarg
+                      result = stmt
                     }
                 | tLPAREN compstmt tRPAREN
                     {
@@ -938,6 +1073,7 @@ rule
                 | tLBRACK aref_args tRBRACK
                     {
                       result = val[1] || s(:array)
+                      result.sexp_type = :array # aref_args is :args
                     }
                 | tLBRACE
                     {
@@ -947,7 +1083,7 @@ rule
                     {
                       result = new_hash val
                     }
-                | kRETURN
+                | k_return
                     {
                       result = s(:return)
                     }
@@ -973,12 +1109,12 @@ rule
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      raise "no3\non#{val.inspect}"
+                      debug20 14, val, result
                     }
-                | operation brace_block
+                | fcall brace_block
                     {
                       oper, iter = val[0], val[1]
-                      call = new_call nil, oper.to_sym
+                      call = oper # FIX
                       iter.insert 1, call
                       result = iter
                       call.line = iter.line
@@ -995,61 +1131,42 @@ rule
                     {
                       result = val[1] # TODO: fix lineno
                     }
-                | kIF expr_value then compstmt if_tail kEND
-                    {
-                      result = new_if val[1], val[3], val[4]
-                    }
-                | kUNLESS expr_value then compstmt opt_else kEND
+                | k_if expr_value then compstmt if_tail k_end
                     {
-                      result = new_if val[1], val[4], val[3]
+                      _, c, _, t, f, _ = val
+                      result = new_if c, t, f
                     }
-                | kWHILE
-                    {
-                      lexer.cond.push true
-                    }
-                    expr_value do
-                    {
-                      lexer.cond.pop
-                    }
-                    compstmt kEND
-                    {
-                      result = new_while val[5], val[2], true
-                    }
-                | kUNTIL
+                | k_unless expr_value then compstmt opt_else k_end
                     {
-                      lexer.cond.push true
+                      _, c, _, t, f, _ = val
+                      result = new_if c, f, t
                     }
-                    expr_value do
+                | k_while expr_value_do compstmt k_end
                     {
-                      lexer.cond.pop
+                      _, cond, body, _ = val
+                      result = new_while body, cond, true
                     }
-                    compstmt kEND
+                | k_until expr_value_do compstmt k_end
                     {
-                      result = new_until val[5], val[2], true
+                      _, cond, body, _ = val
+                      result = new_until body, cond, true
                     }
-                | kCASE expr_value opt_terms case_body kEND
+                | k_case expr_value opt_terms case_body k_end
                     {
                       (_, line), expr, _, body, _ = val
                       result = new_case expr, body, line
                     }
-                | kCASE            opt_terms case_body kEND
+                | k_case            opt_terms case_body k_end
                     {
                       (_, line), _, body, _ = val
                       result = new_case nil, body, line
                     }
-                | kFOR for_var kIN
+                | k_for for_var kIN expr_value_do compstmt k_end
                     {
-                      lexer.cond.push true
+                      _, var, _, iter, body, _ = val
+                      result = new_for iter, var, body
                     }
-                    expr_value do
-                    {
-                      lexer.cond.pop
-                    }
-                    compstmt kEND
-                    {
-                      result = new_for val[4], val[1], val[7]
-                    }
-                | kCLASS
+                | k_class
                     {
                       result = self.lexer.lineno
                     }
@@ -1061,13 +1178,13 @@ rule
                       end
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_class val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kCLASS tLSHFT
+                | k_class tLSHFT
                     {
                       result = self.lexer.lineno
                     }
@@ -1082,13 +1199,13 @@ rule
                       self.in_single = 0
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_sclass val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kMODULE
+                | k_module
                     {
                       result = self.lexer.lineno
                     }
@@ -1100,22 +1217,24 @@ rule
 
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_module val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kDEF fname
+                | k_def fname
                     {
                       result = [self.in_def, self.lexer.cmdarg.stack.dup]
 
                       self.comments.push self.lexer.comments
                       self.in_def = true
                       self.env.extend
+                      # TODO: local->cmdargs = cmdarg_stack;
+                      # TODO: port local_push_gen and local_pop_gen
                       lexer.cmdarg.stack.replace [false]
                     }
-                    f_arglist bodystmt kEND
+                    f_arglist bodystmt k_end
                     {
                       in_def, cmdarg = val[2]
 
@@ -1126,7 +1245,7 @@ rule
                       self.in_def = in_def
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kDEF singleton dot_or_colon
+                | k_def singleton dot_or_colon
                     {
                       self.comments.push self.lexer.comments
                       lexer.lex_state = :expr_fname
@@ -1135,17 +1254,18 @@ rule
                     {
                       self.in_single += 1
                       self.env.extend
-                      lexer.lex_state = :expr_end # force for args
+                      lexer.lex_state = :expr_endfn # force for args
                       result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
                       lexer.cmdarg.stack.replace [false]
                     }
-                    f_arglist bodystmt kEND
+                    f_arglist bodystmt k_end
                     {
                       line, cmdarg = val[5]
                       result = new_defs val
                       result[3].line line
 
                       lexer.cmdarg.stack.replace cmdarg
+
                       self.env.unextend
                       self.in_single -= 1
                       self.lexer.comments # we don't care about comments in the body
@@ -1183,7 +1303,15 @@ rule
          k_class: kCLASS
         k_module: kMODULE
            k_def: kDEF
+            k_do: kDO
+      k_do_block: kDO_BLOCK
+        k_rescue: kRESCUE
+        k_ensure: kENSURE
+          k_when: kWHEN
+          k_else: kELSE
+         k_elsif: kELSIF
            k_end: kEND
+        k_return: kRETURN
 
             then: term
                 | kTHEN
@@ -1193,7 +1321,7 @@ rule
                 | kDO_COND
 
          if_tail: opt_else
-                | kELSIF expr_value then compstmt if_tail
+                | k_elsif expr_value then compstmt if_tail
                     {
                       result = s(:if, val[1], val[3], val[4])
                     }
@@ -1278,23 +1406,46 @@ rule
                       result = block_var :*, args
                     }
 
-     block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
+ block_args_tail: f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
+                    {
+                      result = call_args val
+                    }
+                | f_block_kwarg opt_f_block_arg
+                    {
+                      result = call_args val
+                    }
+                | f_kwrest opt_f_block_arg
+                    {
+                      result = call_args val
+                    }
+                | f_block_arg
+                    {
+                      result = call_args val
+                    }
+
+opt_block_args_tail: tCOMMA block_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | none
+
+     block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
+                    {
+                      result = args val
+                    }
+                | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_block_optarg opt_f_block_arg
+                | f_arg tCOMMA f_block_optarg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_f_block_arg
+                | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_rest_arg opt_f_block_arg
+                | f_arg tCOMMA f_rest_arg opt_block_args_tail
                     {
                       result = args val
                     }
@@ -1302,64 +1453,68 @@ rule
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_arg opt_f_block_arg
+                | f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
+                | f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_block_optarg opt_f_block_arg
+                | f_block_optarg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_block_optarg tCOMMA f_arg opt_f_block_arg
+                | f_block_optarg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = args val
                     }
-                | f_block_arg
+                | block_args_tail
                     {
                       result = args val
                     }
 
  opt_block_param: none { result = 0 }
                 | block_param_def
+                    {
+                      self.lexer.command_start = true
+                    }
 
  block_param_def: tPIPE opt_bv_decl tPIPE
                     {
+                      # TODO: current_arg = 0
                       result = args val
                     }
                 | tOROP
                     {
                       result = s(:args)
-                      self.lexer.command_start = true
                     }
                 | tPIPE block_param opt_bv_decl tPIPE
                     {
+                      # TODO: current_arg = 0
                       result = args val
                     }
 
-     opt_bv_decl: none
-                | tSEMI bv_decls
+     opt_bv_decl: opt_nl
+                | opt_nl tSEMI bv_decls opt_nl
                     {
-                      result = val[1]
+                      result = args val
                     }
 
         bv_decls: bvar
@@ -1378,18 +1533,29 @@ rule
                 | f_bad_arg
 
           lambda:   {
-                      # TODO: dyna_push ? hrm
+                      self.env.extend :dynamic
+                      result = self.lexer.lineno
+
                       result = lexer.lpar_beg
                       lexer.paren_nest += 1
                       lexer.lpar_beg = lexer.paren_nest
                     }
-                    f_larglist lambda_body
+                    f_larglist
+                    {
+                      result = [lexer.cmdarg.store(false), self.lexer.lineno]
+                    }
+                    lambda_body
                     {
-                      lpar, args, body = val
+                      lpar, args, (cmdarg, lineno), body = val
                       lexer.lpar_beg = lpar
 
+                      lexer.cmdarg.restore cmdarg
+                      lexer.cmdarg.lexpop
+
                       call = new_call nil, :lambda
                       result = new_iter call, args, body
+                      result.line = lineno
+                      self.env.unextend
                     }
 
      f_larglist: tLPAREN2 f_args opt_bv_decl rparen
@@ -1406,35 +1572,22 @@ rule
                     {
                       result = val[1]
                     }
-                | kDO_LAMBDA compstmt kEND
+                | kDO_LAMBDA bodystmt kEND
                     {
                       result = val[1]
                     }
 
-        do_block: kDO_BLOCK
-                    {
-                      self.env.extend :dynamic
-                      result = self.lexer.lineno
-                    }
-                    opt_block_param
+        do_block: k_do_block do_body kEND
                     {
-                      result = nil # self.env.dynamic.keys
-                    }
-                    compstmt kEND
-                    {
-                      args   = val[2]
-                      body   = val[4]
-                      result = new_iter nil, args, body
-                      result.line = val[1]
-
-                      self.env.unextend
+                      # TODO: maybe fix lineno to kDO's lineno?
+                      result = val[1]
                     }
 
       block_call: command do_block
                     {
                       # TODO:
-                      # if (nd_type($1) == NODE_YIELD) {
-                      #     compile_error(PARSER_ARG "block given to yield");
+                      ## if (nd_type($1) == NODE_YIELD) {
+                      ##     compile_error(PARSER_ARG "block given to yield");
 
                       syntax_error "Both block arg and actual block given." if
                         val[0].block_pass?
@@ -1444,26 +1597,41 @@ rule
                       result = val[1]
                       result.insert 1, val[0]
                     }
-                | block_call tDOT operation2 opt_paren_args
+                | block_call call_op2 operation2 opt_paren_args
                     {
                       result = new_call val[0], val[2].to_sym, val[3]
                     }
-                | block_call tCOLON2 operation2 opt_paren_args
+                | block_call call_op2 operation2 opt_paren_args brace_block
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      iter1, _, name, args, iter2 = val
+
+                      call = new_call iter1, name.to_sym, args
+                      iter2.insert 1, call
+
+                      result = iter2
+                    }
+                | block_call call_op2 operation2 command_args do_block
+                    {
+                      iter1, _, name, args, iter2 = val
+
+                      call = new_call iter1, name.to_sym, args
+                      iter2.insert 1, call
+
+                      result = iter2
                     }
 
-     method_call: operation
+     method_call: fcall
                     {
                       result = self.lexer.lineno
                     }
                     paren_args
                     {
-                      result = new_call nil, val[0].to_sym, val[2]
+                      args = self.call_args val[2..-1]
+                      result = val[0].concat args.sexp_body
                     }
-                | primary_value tDOT operation2 opt_paren_args
+                | primary_value call_op operation2 opt_paren_args
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      result = new_call val[0], val[2].to_sym, val[3], val[1]
                     }
                 | primary_value tCOLON2 operation2 paren_args
                     {
@@ -1473,9 +1641,9 @@ rule
                     {
                       result = new_call val[0], val[2].to_sym
                     }
-                | primary_value tDOT paren_args
+                | primary_value call_op paren_args
                     {
-                      result = new_call val[0], :call, val[2]
+                      result = new_call val[0], :call, val[2], val[1]
                     }
                 | primary_value tCOLON2 paren_args
                     {
@@ -1499,39 +1667,55 @@ rule
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                    opt_block_param
-                    {
-                      result = nil # self.env.dynamic.keys
-                    }
-                    compstmt tRCURLY
+                    brace_body tRCURLY
                     {
-                      _, line, args, _, body, _ = val
+                      _, line, body, _ = val
 
-                      result = new_iter nil, args, body
+                      result = body
                       result.line = line
 
                       self.env.unextend
                     }
-                | kDO
+                | k_do
                     {
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                 opt_block_param
+                    do_body kEND
                     {
-                      result = nil # self.env.dynamic.keys
+                      _, line, body, _ = val
+
+                      result = body
+                      result.line = line
+
+                      self.env.unextend
                     }
-                    compstmt kEND
+
+      brace_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
+                    { result = lexer.cmdarg.store(false) }
+                    opt_block_param compstmt
                     {
-                      _, line, args, _, body, _ = val
+                      line, cmdarg, param, cmpstmt = val
 
-                      result = new_iter nil, args, body
-                      result.line = line
+                      result = new_brace_body param, cmpstmt, line
+                      self.env.unextend
+                      lexer.cmdarg.restore cmdarg
+                      lexer.cmdarg.pop # because of: cmdarg_stack >> 1 ?
+                    }
+
+         do_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
+                    { result = lexer.cmdarg.store(false) }
+                    opt_block_param
+                    bodystmt
+                    {
+                      line, cmdarg, param, cmpstmt = val
 
+                      result = new_do_body param, cmpstmt, line
                       self.env.unextend
+                      lexer.cmdarg.restore cmdarg
                     }
 
-       case_body: kWHEN
+       case_body: k_when
                     {
                       result = self.lexer.lineno
                     }
@@ -1544,7 +1728,7 @@ rule
 
            cases: opt_else | case_body
 
-      opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
+      opt_rescue: k_rescue exc_list exc_var then compstmt opt_rescue
                     {
                       (_, line), klasses, var, _, body, rest = val
 
@@ -1573,7 +1757,7 @@ rule
                     }
                 | none
 
-      opt_ensure: kENSURE compstmt
+      opt_ensure: k_ensure compstmt
                     {
                       _, body = val
 
@@ -1581,8 +1765,14 @@ rule
                     }
                 | none
 
-         literal: numeric { result = s(:lit, val[0]) }
-                | symbol  { result = s(:lit, val[0]) }
+         literal: numeric
+                    {
+                      result = s(:lit, val[0])
+                    }
+                | symbol
+                    {
+                      result = s(:lit, val[0])
+                    }
                 | dsym
 
          strings: string
@@ -1591,7 +1781,11 @@ rule
                       result = val[0]
                     }
 
-          string: string1
+          string: tCHAR
+                    {
+                      debug20 23, val, result
+                    }
+                | string1
                 | string string1
                     {
                       result = self.literal_concat val[0], val[1]
@@ -1631,7 +1825,7 @@ rule
                     }
                 | word_list word tSPACE
                     {
-                      result = val[0] << new_word_list_entry(val)
+                      result = val[0].dup << new_word_list_entry(val)
                     }
 
             word: string_content
@@ -1640,6 +1834,24 @@ rule
                       result = self.literal_concat val[0], val[1]
                     }
 
+         symbols: tSYMBOLS_BEG tSPACE tSTRING_END
+                    {
+                      result = s(:array)
+                    }
+                | tSYMBOLS_BEG symbol_list tSTRING_END
+                    {
+                      result = val[1]
+                    }
+
+     symbol_list: none
+                    {
+                      result = new_symbol_list
+                    }
+                | symbol_list word tSPACE
+                    {
+                      result = val[0].dup << new_symbol_list_entry(val)
+                    }
+
           qwords: tQWORDS_BEG tSPACE tSTRING_END
                     {
                       result = s(:array)
@@ -1649,13 +1861,31 @@ rule
                       result = val[1]
                     }
 
+        qsymbols: tQSYMBOLS_BEG tSPACE tSTRING_END
+                    {
+                      result = s(:array)
+                    }
+                | tQSYMBOLS_BEG qsym_list tSTRING_END
+                    {
+                      result = val[1]
+                    }
+
       qword_list: none
                     {
                       result = new_qword_list
                     }
                 | qword_list tSTRING_CONTENT tSPACE
                     {
-                      result = val[0] << new_qword_list_entry(val)
+                      result = val[0].dup << new_qword_list_entry(val)
+                    }
+
+       qsym_list: none
+                    {
+                      result = new_qsym_list
+                    }
+                | qsym_list tSTRING_CONTENT tSPACE
+                    {
+                      result = val[0].dup << new_qsym_list_entry(val)
                     }
 
  string_contents: none
@@ -1707,7 +1937,9 @@ regexp_contents: none
                                 lexer.brace_nest,
                                 lexer.string_nest, # TODO: remove
                                 lexer.cond.store,
-                                lexer.cmdarg.store]
+                                lexer.cmdarg.store,
+                                lexer.lex_state,
+                               ]
 
                       lexer.lex_strterm = nil
                       lexer.brace_nest  = 0
@@ -1715,11 +1947,12 @@ regexp_contents: none
 
                       lexer.lex_state   = :expr_beg
                     }
-                    compstmt tRCURLY
+                    compstmt
+                    tSTRING_DEND
                     {
                       _, memo, stmt, _ = val
 
-                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg = memo
+                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state = memo
 
                       lexer.lex_strterm = lex_strterm
                       lexer.brace_nest  = brace_nest
@@ -1728,6 +1961,8 @@ regexp_contents: none
                       lexer.cond.restore oldcond
                       lexer.cmdarg.restore oldcmdarg
 
+                      lexer.lex_state = oldlex_state
+
                       case stmt
                       when Sexp then
                         case stmt.sexp_type
@@ -1739,6 +1974,7 @@ regexp_contents: none
                       when nil then
                         result = s(:evstr)
                       else
+                        debug20 25
                         raise "unknown string body: #{stmt.inspect}"
                       end
                     }
@@ -1771,23 +2007,25 @@ regexp_contents: none
                       when :dstr then
                         result.sexp_type = :dsym
                       when :str then
-                        result = s(:lit, result.last.intern)
-                      else
+                        result = s(:lit, result.last.to_sym)
+                      when :evstr then
                         result = s(:dsym, "", result)
+                      else
+                        debug20 26, val, result
                       end
                     }
 
-         numeric: tINTEGER
-                | tFLOAT
-                | tUMINUS_NUM tINTEGER =tLOWEST
-                    {
-                      result = -val[1] # TODO: pt_testcase
-                    }
-                | tUMINUS_NUM tFLOAT   =tLOWEST
+         numeric: simple_numeric
+                | tUMINUS_NUM simple_numeric
                     {
                       result = -val[1] # TODO: pt_testcase
                     }
 
+  simple_numeric: tINTEGER
+                | tFLOAT
+                | tRATIONAL
+                | tIMAGINARY
+
    user_variable: tIDENTIFIER
                 | tIVAR
                 | tGVAR
@@ -1828,93 +2066,123 @@ keyword_variable: kNIL      { result = s(:nil)   }
                 | keyword_variable
                     {
                       result = self.assignable val[0]
+                      debug20 29, val, result
                     }
 
          backref: tNTH_REF  { result = s(:nth_ref,  val[0]) }
                 | tBACK_REF { result = s(:back_ref, val[0]) }
 
-      superclass: term
-                    {
-                      result = nil
-                    }
-                | tLT
+      superclass: tLT
                     {
                       lexer.lex_state = :expr_beg
+                      lexer.command_start = true
                     }
                     expr_value term
                     {
                       result = val[2]
                     }
-                | error term
+                | none
                     {
-                      yyerrok
                       result = nil
                     }
 
        f_arglist: tLPAREN2 f_args rparen
                     {
                       result = val[1]
-                      lexer.lex_state = :expr_beg
+                      self.lexer.lex_state = :expr_beg
                       self.lexer.command_start = true
                     }
-                | f_args term
+                |   {
+                      result = self.in_kwarg
+                      self.in_kwarg = true
+                      # TODO: self.lexer.lex_state |= :expr_label
+                    }
+                    f_args term
                     {
-                      result = val[0]
+                      kwarg, args, _ = val
+
+                      self.in_kwarg = kwarg
+                      result = args
+                      lexer.lex_state     = :expr_beg
+                      lexer.command_start = true
+                    }
+
+       args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
+                    {
+                      result = args val
+                    }
+                | f_kwarg opt_f_block_arg
+                    {
+                      result = args val
                     }
+                | f_kwrest opt_f_block_arg
+                    {
+                      result = args val
+                    }
+                | f_block_arg
 
-          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_f_block_arg
+   opt_args_tail: tCOMMA args_tail
+                    {
+                      result = val[1]
+                    }
+                |
+                    {
+                      result = nil
+                    }
+
+          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_optarg              opt_f_block_arg
+                | f_arg tCOMMA f_optarg              opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_optarg tCOMMA f_arg opt_f_block_arg
+                | f_arg tCOMMA f_optarg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA            f_rest_arg opt_f_block_arg
+                | f_arg tCOMMA            f_rest_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_arg                             opt_f_block_arg
+                | f_arg                             opt_args_tail
                     {
                       result = args val
                     }
-                |           f_optarg tCOMMA f_rest_arg opt_f_block_arg
+                |           f_optarg tCOMMA f_rest_arg opt_args_tail
                     {
                       result = args val
                     }
-                | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+                | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                |           f_optarg                opt_f_block_arg
+                |           f_optarg                opt_args_tail
                     {
                       result = args val
                     }
-                | f_optarg tCOMMA f_arg opt_f_block_arg
+                | f_optarg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                |                        f_rest_arg opt_f_block_arg
+                |                        f_rest_arg opt_args_tail
                     {
                       result = args val
                     }
-                |           f_rest_arg tCOMMA f_arg opt_f_block_arg
+                |           f_rest_arg tCOMMA f_arg opt_args_tail
                     {
                       result = args val
                     }
-                |                                       f_block_arg
+                |                                       args_tail
                     {
                       result = args val
                     }
@@ -1949,7 +2217,9 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       result = identifier
                     }
 
-      f_arg_item: f_norm_arg
+      f_arg_asgn: f_norm_arg
+
+      f_arg_item: f_arg_asgn
                 | tLPAREN f_margs rparen
                     {
                       result = val[1]
@@ -1964,6 +2234,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       when Sexp then
                         result = val[0]
                       else
+                        debug20 32
                         raise "Unknown f_arg type: #{val.inspect}"
                       end
                     }
@@ -1980,13 +2251,78 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       result << item
                     }
 
-           f_opt: tIDENTIFIER tEQL arg_value
+         f_label: tLABEL
+
+            f_kw: f_label arg_value
+                    {
+                      # TODO: call_args
+                      label, _ = val[0] # TODO: fix lineno?
+                      identifier = label.to_sym
+                      self.env[identifier] = :lvar
+
+                      result = s(:array, s(:kwarg, identifier, val[1]))
+                    }
+                | f_label
+                    {
+                      label, _ = val[0] # TODO: fix lineno?
+                      identifier = label.to_sym
+                      self.env[identifier] = :lvar
+
+                      result = s(:array, s(:kwarg, identifier))
+                    }
+
+      f_block_kw: f_label primary_value
+                    {
+                      # TODO: call_args
+                      label, _ = val[0] # TODO: fix lineno?
+                      identifier = label.to_sym
+                      self.env[identifier] = :lvar
+
+                      result = s(:array, s(:kwarg, identifier, val[1]))
+                    }
+                | f_label
+                    {
+                      label, _ = val[0] # TODO: fix lineno?
+                      identifier = label.to_sym
+                      self.env[identifier] = :lvar
+
+                      result = s(:array, s(:kwarg, identifier))
+                    }
+
+   f_block_kwarg: f_block_kw
+                | f_block_kwarg tCOMMA f_block_kw
+                    {
+                      list, _, item = val
+                      result = list << item.last
+                    }
+
+         f_kwarg: f_kw
+                | f_kwarg tCOMMA f_kw
+                    {
+                      result = args val
+                    }
+
+     kwrest_mark: tPOW
+                | tDSTAR
+
+        f_kwrest: kwrest_mark tIDENTIFIER
+                    {
+                      name = val[1].to_sym
+                      self.assignable name
+                      result = :"**#{name}"
+                    }
+                | kwrest_mark
+                    {
+                      result = :"**"
+                    }
+
+           f_opt: f_arg_asgn tEQL arg_value
                     {
                       result = self.assignable val[0], val[2]
                       # TODO: detect duplicate names
                     }
 
-     f_block_opt: tIDENTIFIER tEQL primary_value
+     f_block_opt: f_arg_asgn tEQL primary_value
                     {
                       result = self.assignable val[0], val[2]
                     }
@@ -2073,22 +2409,39 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       more = val[2].sexp_body
                       list.push(*more) unless more.empty?
                       result = list
+                      result.sexp_type = :hash
                     }
 
            assoc: arg_value tASSOC arg_value
                     {
                       result = s(:array, val[0], val[2])
                     }
-                | tLABEL opt_nl arg_value
+                | tLABEL arg_value
                     {
-                      label, _ = val[0] # TODO: fix lineno?
-                      result = s(:array, s(:lit, label.to_sym), val.last)
+                      (label, _), arg = val
+                      result = s(:array, s(:lit, label.to_sym), arg)
+                    }
+                | tSTRING_BEG string_contents tLABEL_END arg_value
+                    {
+                      _, sym, _, value = val
+                      sym.sexp_type = :dsym
+                      result = s(:array, sym, value)
+                    }
+                | tDSTAR arg_value
+                    {
+                      result = s(:array, s(:kwsplat, val[1]))
                     }
 
        operation: tIDENTIFIER | tCONSTANT | tFID
       operation2: tIDENTIFIER | tCONSTANT | tFID | op
       operation3: tIDENTIFIER | tFID | op
     dot_or_colon: tDOT | tCOLON2
+         call_op: tDOT
+                | tLONELY # TODO: rename tANDDOT?
+
+        call_op2: call_op
+                | tCOLON2
+
        opt_terms:  | terms
           opt_nl:  | tNL
           rparen: opt_nl tRPAREN
@@ -2101,7 +2454,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
            terms: term
                 | terms tSEMI { yyerrok }
 
-            none: { result = nil }
+            none: { result = nil; }
 end
 
 ---- inner