brakeman 5.0.2 → 5.1.2

data/bundle/ruby/2.7.0/gems/{ruby_parser-3.16.0/lib/ruby_parser.yy → ruby_parser-3.18.0/lib/ruby27_parser.y}

@@ -1,26 +1,6 @@
 # -*- racc -*-
 
-#if V==20
-class Ruby20Parser
-#elif V==21
-class Ruby21Parser
-#elif V == 22
-class Ruby22Parser
-#elif V == 23
-class Ruby23Parser
-#elif V == 24
-class Ruby24Parser
-#elif V == 25
-class Ruby25Parser
-#elif V == 26
-class Ruby26Parser
-#elif V == 27
 class Ruby27Parser
-#elif V == 30
-class Ruby30Parser
-#else
-fail "version not specified or supported on code generation"
-#endif
 
 token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
@@ -38,19 +18,11 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       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 tLAMBDA
-      tLAMBEG tDSTAR tCHAR tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DEND tUBANG
-#if V >= 21
+      tLAMBEG tDSTAR tCHAR tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DEND
       tRATIONAL tIMAGINARY
-#endif
-#if V >= 22
       tLABEL_END
-#endif
-#if V >= 23
        tLONELY
-#endif
-#if V >= 26
        tBDOT2 tBDOT3
-#endif
 
 preclow
   nonassoc tLOWEST
@@ -108,7 +80,7 @@ rule
                 | klBEGIN
                     {
                       if (self.in_def || self.in_single > 0) then
-                        debug20 1
+                        debug 11
                         yyerror "BEGIN in method"
                       end
                       self.env.extend
@@ -133,6 +105,8 @@ rule
         bodystmt: compstmt opt_rescue k_else
                     {
                       res = _values[-2]
+                      # TODO: move down to main match so I can just use val
+
                       yyerror "else without rescue is useless" unless res
                     }
                     compstmt
@@ -163,7 +137,7 @@ rule
                 | error stmt
                     {
                       result = val[1]
-                      debug20 2, val, result
+                      debug 12
                     }
 
    stmt_or_begin: stmt
@@ -171,6 +145,10 @@ rule
                     {
                       yyerror "BEGIN is permitted only at toplevel"
                     }
+                  begin_block
+                    {
+                      result = val[2] # wtf?
+                    }
 
             stmt: kALIAS fitem
                     {
@@ -183,12 +161,12 @@ rule
                     }
                 | kALIAS tGVAR tGVAR
                     {
-                      (_, line), lhs, rhs = val
+                      (_, line), (lhs, _), (rhs, _) = val
                       result = s(:valias, lhs.to_sym, rhs.to_sym).line line
                     }
                 | kALIAS tGVAR tBACK_REF
                     {
-                      (_, line), lhs, rhs = val
+                      (_, line), (lhs, _), (rhs, _) = val
                       result = s(:valias, lhs.to_sym, :"$#{rhs}").line line
                     }
                 | kALIAS tGVAR tNTH_REF
@@ -231,7 +209,7 @@ rule
                       (_, line), _, stmt, _ = val
 
                       if (self.in_def || self.in_single > 0) then
-                        debug20 3
+                        debug 13
                         yyerror "END in method; use at_exit"
                       end
 
@@ -247,15 +225,16 @@ rule
                       lhs, _, rhs = val
                       result = new_assign lhs, s(:svalue, rhs).line(rhs.line)
                     }
-#if V == 20
-                | mlhs tEQL arg_value
+                | mlhs tEQL mrhs_arg kRESCUE_MOD stmt
                     {
-                      result = new_masgn val[0], val[2], :wrap
+                      # unwraps s(:to_ary, rhs)
+                      lhs, _, (_, rhs), _, resbody = val
+
+                      resbody = new_resbody s(:array).line(resbody.line), resbody
+
+                      result = new_masgn lhs, new_rescue(rhs, resbody), :wrap
                     }
-                | mlhs tEQL mrhs
-#else
                 | mlhs tEQL mrhs_arg
-#endif
                     {
                       result = new_masgn val[0], val[2]
                     }
@@ -279,32 +258,31 @@ rule
                     }
                 | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
-                      prim, _, id, opasgn, rhs = val
-                      result = s(:op_asgn, prim, rhs, id.to_sym, opasgn.to_sym)
-                      if val[1] == '&.'
-                        result.sexp_type = :safe_op_asgn
-                      end
-                      result.line = val[0].line
+                      prim, (call_op, _), (id, _), (op_asgn, _), rhs = val
+
+                      result = s(:op_asgn, prim, rhs, id.to_sym, op_asgn.to_sym)
+                      result.sexp_type = :safe_op_asgn if call_op == '&.'
+                      result.line prim.line
                     }
                 | 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
+                      prim, (call_op, _), (id, _), (op_asgn, _), rhs = val
+
+                      result = s(:op_asgn, prim, rhs, id.to_sym, op_asgn.to_sym)
+                      result.sexp_type = :safe_op_asgn if call_op == '&.'
+                      result.line prim.line
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
-                      lhs1, _, lhs2, op, rhs = val
+                      lhs1, _, (lhs2, line), (id, _), rhs = val
 
-                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, id.to_sym).line line
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
-                      lhs1, _, lhs2, op, rhs = val
+                      lhs1, _, (lhs2, line), (id, _), rhs = val
 
-                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, id.to_sym).line line
                     }
                 | backref tOP_ASGN command_rhs
                     {
@@ -316,7 +294,6 @@ rule
                       expr, = val
                       result = value_expr expr
                     }
-#if V >= 24
                 | command_call kRESCUE_MOD stmt
                     {
                       expr, (_, line), resbody = val
@@ -325,7 +302,6 @@ rule
                       ary  = s(:array).line line
                       result = new_rescue(expr, new_resbody(ary, resbody))
                     }
-#endif
                 | command_asgn
 
             expr: command_call
@@ -353,6 +329,28 @@ rule
                       # REFACTOR: call_uni_op -- see parse26.y
                     }
                 | arg
+                    kIN
+                    {
+                      # TODO? value_expr($1);
+                      self.lexer.lex_state = EXPR_BEG|EXPR_LABEL
+                      self.lexer.command_start = false
+                      result = self.in_kwarg
+                      self.in_kwarg = true
+                      self.env.extend
+                    }
+                    p_expr
+                    {
+                      self.env.unextend
+
+                      expr, _, old_kwarg, pat = val
+
+                      expr = value_expr expr
+
+                      self.in_kwarg = old_kwarg
+                      pat_in = new_in pat, nil, nil, expr.line
+                      result = new_case expr, pat_in, expr.line
+                    }
+                | arg                                   =tLBRACE_ARG
 
       expr_value: expr
                     {
@@ -377,7 +375,7 @@ rule
    block_command: block_call
                 | block_call call_op2 operation2 command_args
                     {
-                      blk, _, msg, args = val
+                      blk, _, (msg, _line), args = val
                       result = new_call(blk, msg.to_sym, args).line blk.line
                     }
 
@@ -391,15 +389,15 @@ rule
                       _, line, body, _ = val
 
                       result = body
-                      result.line = line
+                      result.line line
 
                       # self.env.unextend
                     }
 
            fcall: operation
                     {
-                      msg, = val
-                      result = new_call(nil, msg.to_sym).line lexer.lineno
+                      (msg, line), = val
+                      result = new_call(nil, msg.to_sym).line line
                     }
 
          command: fcall command_args =tLOWEST
@@ -422,12 +420,14 @@ rule
                     }
                 | primary_value call_op operation2 command_args =tLOWEST
                     {
-                      lhs, callop, op, args = val
+                      lhs, callop, (op, _), args = val
+
                       result = new_call lhs, op.to_sym, args, callop
+                      result.line lhs.line
                     }
                 | primary_value call_op operation2 command_args cmd_brace_block
                     {
-                      recv, _, msg, args, block = val
+                      recv, _, (msg, _line), args, block = val
                       call = new_call recv, msg.to_sym, args, val[1]
 
                       block_dup_check call, block
@@ -437,11 +437,14 @@ rule
                     }
                 | primary_value tCOLON2 operation2 command_args =tLOWEST
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      lhs, _, (id, line), args = val
+
+                      result = new_call lhs, id.to_sym, args
+                      result.line line
                     }
                 | primary_value tCOLON2 operation2 command_args cmd_brace_block
                     {
-                      recv, _, msg, args, block = val
+                      recv, _, (msg, _line), args, block = val
                       call = new_call recv, msg.to_sym, args
 
                       block_dup_check call, block
@@ -599,25 +602,29 @@ rule
                     }
                 | primary_value call_op tIDENTIFIER
                     {
-                      result = new_attrasgn val[0], val[2], val[1]
+                      lhs, call_op, (id, _line) = val
+
+                      result = new_attrasgn lhs, id, call_op
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
-                      recv, _, id = val
+                      recv, _, (id, _line) = val
                       result = new_attrasgn recv, id
                     }
                 | primary_value call_op tCONSTANT
                     {
-                      result = new_attrasgn val[0], val[2], val[1]
+                      lhs, call_op, (id, _line) = val
+
+                      result = new_attrasgn lhs, id, call_op
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
-                        debug20 7
+                        debug 14
                         yyerror "dynamic constant assignment"
                       end
 
-                      expr, _, id = val
+                      expr, _, (id, _line) = val
                       l = expr.line
 
                       result = s(:const, s(:colon2, expr, id.to_sym).line(l), nil).line l
@@ -625,58 +632,65 @@ rule
                 | tCOLON3 tCONSTANT
                     {
                       if (self.in_def || self.in_single > 0) then
-                        debug20 8
+                        debug 15
                         yyerror "dynamic constant assignment"
                       end
 
-                      _, id = val
-                      l = lexer.lineno
+                      _, (id, l) = val
 
                       result = s(:const, nil, s(:colon3, id.to_sym).line(l)).line l
                     }
                 | backref
                     {
-                      self.backref_assign_error val[0]
+                      ref, = val
+
+                      self.backref_assign_error ref
                     }
 
              lhs: user_variable
                     {
-                      line = lexer.lineno
-                      result = self.assignable val[0]
-                      result.line = line
+                      var, = val
+
+                      result = self.assignable var
                     }
                 | keyword_variable
                     {
-                      line = lexer.lineno
-                      result = self.assignable val[0]
-                      result.line = line
-                      debug20 9, val, result
+                      var, = val
+
+                      result = self.assignable var
+
+                      debug 16
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket
                     {
                       lhs, _, args, _ = val
+
                       result = self.aryset lhs, args
                     }
                 | primary_value call_op tIDENTIFIER # REFACTOR
                     {
-                      lhs, op, id = val
+                      lhs, op, (id, _line) = val
+
                       result = new_attrasgn lhs, id, op
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
-                      lhs, _, id = val
+                      lhs, _, (id, _line) = val
+
                       result = new_attrasgn lhs, id
                     }
                 | primary_value call_op tCONSTANT # REFACTOR?
                     {
-                      result = new_attrasgn val[0], val[2], val[1]
+                      lhs, call_op, (id, _line) = val
+
+                      result = new_attrasgn lhs, id, call_op
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
-                      expr, _, id = val
+                      expr, _, (id, _line) = val
 
                       if (self.in_def || self.in_single > 0) then
-                        debug20 10
+                        debug 17
                         yyerror "dynamic constant assignment"
                       end
 
@@ -685,14 +699,13 @@ rule
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      _, id = val
+                      _, (id, l) = val
 
                       if (self.in_def || self.in_single > 0) then
-                        debug20 11
+                        debug 18
                         yyerror "dynamic constant assignment"
                       end
 
-                      l = lexer.lineno
                       result = s(:const, s(:colon3, id.to_sym).line(l)).line l
                     }
                 | backref
@@ -708,16 +721,17 @@ rule
 
            cpath: tCOLON3 cname
                     {
-                      _, name = val
-                      result = s(:colon3, name.to_sym).line lexer.lineno
+                      _, (name, line) = val
+                      result = s(:colon3, name.to_sym).line line
                     }
                 | cname
                     {
-                      result = val[0].to_sym
+                      (id, line), = val
+                      result = [id.to_sym, line] # TODO: sexp?
                     }
                 | primary_value tCOLON2 cname
                     {
-                      pval, _, name = val
+                      pval, _, (name, _line) = val
 
                       result = s(:colon2, pval, name.to_sym)
                       result.line pval.line
@@ -727,24 +741,17 @@ rule
                 | op
                     {
                       lexer.lex_state = EXPR_END
-                      result = val[0]
                     }
 
                 | reswords
-                    {
-                      (sym, _line), = val
-                      lexer.lex_state = EXPR_END
-                      result = sym
-                    }
-
-            fsym: fname | symbol
 
-           fitem: fsym
+           fitem: fname
                     {
-                      id, = val
-                      result = s(:lit, id.to_sym).line lexer.lineno
+                      (id, line), = val
+
+                      result = s(:lit, id.to_sym).line line
                     }
-                | dsym
+                | symbol
 
       undef_list: fitem
                     {
@@ -765,10 +772,6 @@ rule
                 |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS | tSTAR2
                 |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tDSTAR | tBANG   | tTILDE
                 |   tUPLUS   | tUMINUS | tAREF    | tASET | tBACK_REF2
-#if V >= 20
-                    # TODO: tUBANG dead?
-                |   tUBANG
-#endif
 
         reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
                 | kALIAS    | kAND      | kBEGIN        | kBREAK  | kCASE
@@ -802,24 +805,20 @@ rule
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                     {
-                      lhs, _, id, op, rhs = val
+                      lhs, _, (id, _line), (op, _), rhs = val
 
                       result = s(:op_asgn, lhs, rhs, id.to_sym, op.to_sym).line lhs.line
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      lhs1, _, lhs2, op, rhs = val
+                      lhs1, _, (lhs2, _line), op, rhs = val
 
                       lhs = s(:colon2, lhs1, lhs2.to_sym).line lhs1.line
                       result = new_const_op_asgn [lhs, op, rhs]
                     }
-                | tCOLON3 tCONSTANT
+                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      result = self.lexer.lineno
-                    }
-                    tOP_ASGN arg_rhs
-                    {
-                      _, lhs, line, op, rhs = val
+                      _, (lhs, line), op, rhs = val
 
                       lhs = s(:colon3, lhs.to_sym).line line
                       result = new_const_op_asgn [lhs, op, rhs]
@@ -833,7 +832,7 @@ rule
                 | arg tDOT2 arg
                     {
                       v1, v2 = val[0], val[2]
-                      if v1.node_type == :lit and v2.node_type == :lit and Integer === v1.last and Integer === v2.last then
+                      if v1.sexp_type == :lit and v2.sexp_type == :lit and Integer === v1.last and Integer === v2.last then
                         result = s(:lit, (v1.last)..(v2.last)).line v1.line
                       else
                         result = s(:dot2, v1, v2).line v1.line
@@ -842,13 +841,12 @@ rule
                 | arg tDOT3 arg
                     {
                       v1, v2 = val[0], val[2]
-                      if v1.node_type == :lit and v2.node_type == :lit and Integer === v1.last and Integer === v2.last then
+                      if v1.sexp_type == :lit and v2.sexp_type == :lit and Integer === v1.last and Integer === v2.last then
                         result = s(:lit, (v1.last)...(v2.last)).line v1.line
                       else
                         result = s(:dot3, v1, v2).line v1.line
                       end
                     }
-#if V >= 26
                 | arg tDOT2
                     {
                       v1, _ = val
@@ -863,9 +861,7 @@ rule
 
                       result = s(:dot3, v1, v2).line v1.line
                     }
-#endif
 
-#if V >= 27
                 | tBDOT2 arg
                     {
                       _, v2, = val
@@ -880,7 +876,6 @@ rule
 
                       result = s(:dot3, v1, v2).line v2.line
                     }
-#endif
 
                 | arg tPLUS arg
                     {
@@ -906,24 +901,12 @@ rule
                     {
                       result = new_call val[0], :**, argl(val[2])
                     }
-#if V == 20
-                | tUMINUS_NUM tINTEGER tPOW arg
-                    {
-                      lit = s(:lit, val[1]).line lexer.lineno
-                      result = new_call(new_call(lit, :"**", argl(val[3])), :"-@")
-                    }
-                | tUMINUS_NUM tFLOAT tPOW arg
-#else
                 | tUMINUS_NUM simple_numeric tPOW arg
-#endif
                     {
-                      lit = s(:lit, val[1]).line lexer.lineno
-                      result = new_call(new_call(lit, :"**", argl(val[3])), :"-@")
+                      _, (num, line), _, arg = val
+                      lit = s(:lit, num).line line
+                      result = new_call(new_call(lit, :"**", argl(arg)), :"-@")
 
-#if V == 20
-                      ## TODO: why is this 2.0 only?
-                      debug20 12, val, result
-#endif
                     }
                 | tUPLUS arg
                     {
@@ -1021,12 +1004,12 @@ rule
 
         rel_expr: arg      relop arg                    =tGT
                     {
-                      lhs, op, rhs = val
+                      lhs, (op, _), rhs = val
                       result = new_call lhs, op.to_sym, argl(rhs)
                     }
                 | rel_expr relop arg                    =tGT
                     {
-                      lhs, op, rhs = val
+                      lhs, (op, _), rhs = val
                       warn "comparison '%s' after comparison", op
                       result = new_call lhs, op.to_sym, argl(rhs)
                     }
@@ -1066,6 +1049,24 @@ rule
                       _, args, _ = val
                       result = args
                     }
+                | tLPAREN2 args tCOMMA args_forward rparen
+                    {
+                      yyerror "Unexpected ..." unless
+                        self.lexer.is_local_id(:"*")  &&
+                        self.lexer.is_local_id(:"**") &&
+                        self.lexer.is_local_id(:"&")
+
+                      result = call_args val
+                    }
+                | tLPAREN2 args_forward rparen
+                    {
+                      yyerror "Unexpected ..." unless
+                        self.lexer.is_local_id(:"*")  &&
+                        self.lexer.is_local_id(:"**") &&
+                        self.lexer.is_local_id(:"&")
+
+                      result = call_args val
+                    }
 
   opt_paren_args: none
                 | paren_args
@@ -1180,7 +1181,6 @@ rule
                       result = self.list_append args, s(:splat, id).line(line)
                     }
 
-#if V >= 21
         mrhs_arg: mrhs
                     {
                       result = new_masgn_arg val[0]
@@ -1190,7 +1190,6 @@ rule
                       result = new_masgn_arg val[0], :wrap
                     }
 
-#endif
             mrhs: args tCOMMA arg_value
                     {
                       result = val[0] << val[2]
@@ -1219,8 +1218,9 @@ rule
                 | backref
                 | tFID
                     {
-                      msg, = val
+                      (msg, line), = val
                       result = new_call nil, msg.to_sym
+                      result.line line
                     }
                 | k_begin
                     {
@@ -1262,15 +1262,15 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
-                      expr, _, id = val
+                      expr, _, (id, _line) = val
 
                       result = s(:colon2, expr, id.to_sym).line expr.line
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      _, id = val
+                      _, (id, line) = val
 
-                      result = s(:colon3, id.to_sym).line lexer.lineno
+                      result = s(:colon3, id.to_sym).line line
                     }
                 | tLBRACK { result = lexer.lineno } aref_args tRBRACK
                     {
@@ -1317,7 +1317,7 @@ rule
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      debug20 14, val, result
+                      debug 20
                     }
                 | fcall brace_block
                     {
@@ -1335,9 +1335,10 @@ rule
                       iter.insert 1, call # FIX
                       result = iter
                     }
-                | tLAMBDA lambda
+                | lambda
                     {
-                      result = val[1] # TODO: fix lineno
+                      expr, = val
+                      result = expr
                     }
                 | k_if expr_value then compstmt if_tail k_end
                     {
@@ -1369,6 +1370,12 @@ rule
                       (_, line), _, body, _ = val
                       result = new_case nil, body, line
                     }
+                | k_case expr_value opt_terms p_case_body k_end
+                    {
+                      (_, line), expr, _, body, _ = val
+
+                      result = new_case expr, body, line
+                    }
                 | k_for for_var kIN expr_value_do compstmt k_end
                     {
                       _, var, _, iter, body, _ = val
@@ -1380,7 +1387,6 @@ rule
                     }
                     cpath superclass
                     {
-                      self.comments.push self.lexer.comments
                       if (self.in_def || self.in_single > 0) then
                         yyerror "class definition in method body"
                       end
@@ -1390,7 +1396,7 @@ rule
                     {
                       result = new_class val
                       self.env.unextend
-                      self.lexer.comments # we don't care about comments in the body
+                      self.lexer.ignore_body_comments
                     }
                 | k_class tLSHFT
                     {
@@ -1411,7 +1417,7 @@ rule
                     {
                       result = new_sclass val
                       self.env.unextend
-                      self.lexer.comments # we don't care about comments in the body
+                      self.lexer.ignore_body_comments
                     }
                 | k_module
                     {
@@ -1419,7 +1425,6 @@ rule
                     }
                     cpath
                     {
-                      self.comments.push self.lexer.comments
                       yyerror "module definition in method body" if
                         self.in_def or self.in_single > 0
 
@@ -1429,7 +1434,7 @@ rule
                     {
                       result = new_module val
                       self.env.unextend
-                      self.lexer.comments # we don't care about comments in the body
+                      self.lexer.ignore_body_comments
                     }
                 | k_def fname
                     {
@@ -1439,21 +1444,17 @@ rule
                       self.env.extend
                       lexer.cmdarg.push false
                       lexer.cond.push false
-
-                      self.comments.push self.lexer.comments
                     }
-                    f_arglist bodystmt { result = lexer.lineno } k_end
+                    f_arglist bodystmt k_end
                     {
-                      in_def = val[2]
-
-                      result = new_defn val
+                      result, in_def = new_defn val
 
                       lexer.cond.pop # group = local_pop
                       lexer.cmdarg.pop
                       self.env.unextend
                       self.in_def = in_def
 
-                      self.lexer.comments # we don't care about comments in the body
+                      self.lexer.ignore_body_comments
                     }
                 | k_def singleton dot_or_colon
                     {
@@ -1461,7 +1462,7 @@ rule
                     }
                     fname
                     {
-                      result = [self.in_def, lexer.lineno]
+                      result = self.in_def
 
                       self.in_single += 1 # TODO: remove?
 
@@ -1471,13 +1472,18 @@ rule
                       lexer.cond.push false
 
                       lexer.lex_state = EXPR_ENDFN|EXPR_LABEL
-                      self.comments.push self.lexer.comments
                     }
                     f_arglist bodystmt k_end
                     {
-                      _, _recv, _, _, _name, (in_def, _lineno), _args, _body, _ = val
 
-                      result = new_defs val
+                      # [kdef, recv, _, _, (name, line), in_def, args, body, kend]
+                      # =>
+                      # [kdef, recv, (name, line), in_def, args, body, kend]
+
+                      val.delete_at 3
+                      val.delete_at 2
+
+                      result, in_def = new_defs val
 
                       lexer.cond.pop # group = local_pop
                       lexer.cmdarg.pop
@@ -1488,7 +1494,7 @@ rule
 
                       # TODO: restore cur_arg ? what's cur_arg?
 
-                      self.lexer.comments # we don't care about comments in the body
+                      self.lexer.ignore_body_comments
                     }
                 | kBREAK
                     {
@@ -1525,8 +1531,17 @@ rule
           k_case: kCASE
            k_for: kFOR
          k_class: kCLASS
+                    {
+                      self.comments.push self.lexer.comments
+                    }
         k_module: kMODULE
+                    {
+                      self.comments.push self.lexer.comments
+                    }
            k_def: kDEF
+                    {
+                      self.comments.push self.lexer.comments
+                    }
             k_do: kDO
       k_do_block: kDO_BLOCK
         k_rescue: kRESCUE
@@ -1587,51 +1602,42 @@ rule
 
                       result = block_var args
                     }
-                | f_marg_list tCOMMA tSTAR f_norm_arg
+                | f_marg_list tCOMMA f_rest_marg
                     {
-                      args, _, _, splat = val
+                      args, _, rest = val
 
-                      result = block_var args, "*#{splat}".to_sym
+                      result = block_var args, rest
                     }
-                | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
+                | f_marg_list tCOMMA f_rest_marg tCOMMA f_marg_list
                     {
-                      args, _, _, splat, _, args2 = val
+                      lhs, _, splat, _, rhs = val
 
-                      result = block_var args, "*#{splat}".to_sym, args2
+                      result = block_var lhs, splat, rhs
                     }
-                | f_marg_list tCOMMA tSTAR
+                | f_rest_marg
                     {
-                      args, _, _ = val
+                      rest, = val
 
-                      result = block_var args, :*
+                      result = block_var rest
                     }
-                | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
+                | f_rest_marg tCOMMA f_marg_list
                     {
-                      args, _, _, _, args2 = val
+                      splat, _, rest = val
 
-                      result = block_var args, :*, args2
+                      result = block_var splat, rest
                     }
-                | tSTAR f_norm_arg
-                    {
-                      _, splat = val
 
-                      result = block_var :"*#{splat}"
-                    }
-                | tSTAR f_norm_arg tCOMMA f_marg_list
+     f_rest_marg: tSTAR f_norm_arg
                     {
-                      _, splat, _, args = val
+                      _, (id, line) = val
 
-                      result = block_var :"*#{splat}", args
+                      result = args ["*#{id}".to_sym]
+                      result.line line
                     }
                 | tSTAR
                     {
-                      result = block_var :*
-                    }
-                | tSTAR tCOMMA f_marg_list
-                    {
-                      _, _, args = val
-
-                      result = block_var :*, args
+                      result = args [:*]
+                      result.line lexer.lineno # FIX: tSTAR -> line
                     }
 
  block_args_tail: f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
@@ -1646,10 +1652,14 @@ rule
                     {
                       result = call_args val
                     }
+                | f_no_kwarg opt_f_block_arg
+                    {
+                      result = args val
+                    }
                 | f_block_arg
                     {
-                      line = lexer.lineno
-                      result = call_args val # TODO: push line down
+                      (id, line), = val
+                      result = call_args [id]
                       result.line line
                     }
 
@@ -1758,13 +1768,13 @@ opt_block_args_tail: tCOMMA block_args_tail
 
             bvar: tIDENTIFIER
                     {
-                      id, = val
-                      line = lexer.lineno
+                      (id, line), = val
                       result = s(:shadow, id.to_sym).line line
                     }
                 | f_bad_arg
 
-          lambda:   {
+          lambda: tLAMBDA
+                    {
                       self.env.extend :dynamic
                       result = [lexer.lineno, lexer.lpar_beg]
                       lexer.paren_nest += 1
@@ -1776,14 +1786,14 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                     lambda_body
                     {
-                      (line, lpar), args, _cmdarg, body = val
+                      _, (line, lpar), args, _cmdarg, body = val
                       lexer.lpar_beg = lpar
 
                       lexer.cmdarg.pop
 
                       call = s(:lambda).line line
                       result = new_iter call, args, body
-                      result.line = line
+                      result.line line
                       self.env.unextend # TODO: dynapush & dynapop
                     }
 
@@ -1818,23 +1828,28 @@ opt_block_args_tail: tCOMMA block_args_tail
                       ## 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?
+                      cmd, blk = val
 
-                      val = invert_block_call val if inverted? val
+                      syntax_error "Both block arg and actual block given." if
+                        cmd.block_pass?
 
-                      cmd, blk = val
+                      if inverted? val then
+                        val = invert_block_call val
+                        cmd, blk = val
+                      end
 
                       result = blk
                       result.insert 1, cmd
                     }
                 | block_call call_op2 operation2 opt_paren_args
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      lhs, _, (id, _line), args = val
+
+                      result = new_call lhs, id.to_sym, args
                     }
                 | block_call call_op2 operation2 opt_paren_args brace_block
                     {
-                      iter1, _, name, args, iter2 = val
+                      iter1, _, (name, _line), args, iter2 = val
 
                       call = new_call iter1, name.to_sym, args
                       iter2.insert 1, call
@@ -1843,7 +1858,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | block_call call_op2 operation2 command_args do_block
                     {
-                      iter1, _, name, args, iter2 = val
+                      iter1, _, (name, _line), args, iter2 = val
 
                       call = new_call iter1, name.to_sym, args
                       iter2.insert 1, call
@@ -1851,28 +1866,29 @@ opt_block_args_tail: tCOMMA block_args_tail
                       result = iter2
                     }
 
-     method_call: fcall
+     method_call: fcall paren_args
                     {
-                      result = self.lexer.lineno
-                    }
-                    paren_args
-                    {
-                      call, lineno, args = val
+                      call, args = val
 
                       result = call.concat args.sexp_body if args
-                      result.line lineno
                     }
                 | primary_value call_op operation2 opt_paren_args
                     {
-                      result = new_call val[0], val[2].to_sym, val[3], val[1]
+                      recv, call_op, (op, _line), args = val
+
+                      result = new_call recv, op.to_sym, args, call_op
                     }
                 | primary_value tCOLON2 operation2 paren_args
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      recv, _, (op, _line), args = val
+
+                      result = new_call recv, op.to_sym, args
                     }
                 | primary_value tCOLON2 operation3
                     {
-                      result = new_call val[0], val[2].to_sym
+                      lhs, _, (id, _line) = val
+
+                      result = new_call lhs, id.to_sym
                     }
                 | primary_value call_op paren_args
                     {
@@ -1905,7 +1921,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       _, line, body, _ = val
 
                       result = body
-                      result.line = line
+                      result.line line
 
                       self.env.unextend
                     }
@@ -1919,7 +1935,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       _, line, body, _ = val
 
                       result = body
-                      result.line = line
+                      result.line line
 
                       self.env.unextend
                     }
@@ -1939,11 +1955,7 @@ opt_block_args_tail: tCOMMA block_args_tail
          do_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
                     { lexer.cmdarg.push false }
                     opt_block_param
-#if V >= 25
                     bodystmt
-#else
-                    compstmt
-#endif
                     {
                       line, _cmdarg, param, cmpstmt = val
 
@@ -1952,18 +1964,546 @@ opt_block_args_tail: tCOMMA block_args_tail
                       self.env.unextend
                     }
 
+       case_args: arg_value
+                    {
+                      arg, = val
+
+                      result = s(:array, arg).line arg.line
+                    }
+                | tSTAR arg_value
+                    {
+                      _, arg = val
+
+                      result = s(:array, s(:splat, arg).line(arg.line)).line arg.line
+                    }
+                | case_args tCOMMA arg_value
+                    {
+                      args, _, id = val
+
+                      result = self.list_append args, id
+                    }
+                | case_args tCOMMA tSTAR arg_value
+                    {
+                      args, _, _, id = val
+
+                      result = self.list_append args, s(:splat, id).line(id.line)
+                    }
+
        case_body: k_when
                     {
                       result = self.lexer.lineno
                     }
-                    args then compstmt cases
+                    case_args then compstmt cases
                     {
                       result = new_when(val[2], val[4])
-                      result.line = val[1]
+                      result.line val[1]
                       result << val[5] if val[5]
                     }
 
            cases: opt_else | case_body
+######################################################################
+
+     p_case_body: kIN
+                    {
+                      self.lexer.lex_state = EXPR_BEG|EXPR_LABEL
+                      self.lexer.command_start = false
+                      result = self.in_kwarg
+                      self.in_kwarg = true
+                      push_pvtbl
+                      push_pktbl
+                    }
+                    p_top_expr then
+                    {
+                      pop_pktbl
+                      pop_pvtbl
+                      old_kwargs = _values[-3]
+                      self.in_kwarg = old_kwargs
+                    }
+                    compstmt
+                    p_cases
+                    {
+                      (_, line), _, pat, _, _, body, cases = val
+
+                      result = new_in pat, body, cases, line
+                    }
+
+         p_cases: opt_else
+                | p_case_body
+
+      p_top_expr: p_top_expr_body
+                | p_top_expr_body kIF_MOD expr_value
+                    {
+                      body, _, cond = val
+                      body = remove_begin body
+
+                      result = s(:if, cond, body, nil).line body.line
+                    }
+                | p_top_expr_body kUNLESS_MOD expr_value
+                    {
+                      body, _, cond = val
+                      body = remove_begin body
+
+                      result = s(:if, cond, nil, body).line body.line
+                    }
+
+ p_top_expr_body: p_expr
+                | p_expr tCOMMA
+                    {
+                      expr, _ = val
+
+                      tail = new_array_pattern_tail nil, true, nil, nil
+                      result = new_array_pattern nil, expr, tail, expr.line
+                    }
+                | p_expr tCOMMA p_args
+                    {
+                      expr, _, args = val
+
+                      result = new_array_pattern nil, expr, args, expr.line
+                    }
+                | p_args_tail
+                    {
+                      args, = val
+                      result = new_array_pattern nil, nil, args, args.line
+                    }
+                | p_kwargs
+                    {
+                      kwargs, = val
+                      result = new_hash_pattern nil, kwargs, kwargs.line
+                    }
+
+          p_expr: p_as
+
+            p_as: p_expr tASSOC p_variable
+                    {
+                      # NODE *n = NEW_LIST($1, &@$);
+                      # n = list_append(p, n, $3);
+                      # $$ = new_hash(p, n, &@$);
+
+                      expr, _, var = val
+
+                      id = var.last
+
+                      self.env[id] = :lvar # HACK: need to extend env
+                      lhs = s(:lasgn, id).line var.line
+
+                      result = new_assign lhs, expr
+                    }
+                | p_alt
+
+           p_alt: p_alt tPIPE p_expr_basic
+                    {
+                      lhs, _, rhs = val
+
+                      result = s(:or, lhs, rhs).line lhs.line
+                    }
+                | p_expr_basic
+
+        p_lparen: tLPAREN2 { push_pktbl }
+      p_lbracket: tLBRACK2 { push_pktbl }
+
+    p_expr_basic: p_value
+                | p_const p_lparen p_args tRPAREN
+                    {
+                      lhs, _, args, _ = val
+
+                      pop_pktbl
+                      result = new_array_pattern(lhs, nil, args, lhs.line)
+                    }
+                | p_const p_lparen p_kwargs tRPAREN
+                    {
+                      lhs, _, kwargs, _ = val
+
+                      pop_pktbl
+                      result = new_hash_pattern(lhs, kwargs, lhs.line)
+                    }
+                | p_const tLPAREN2 tRPAREN
+                    {
+                      const, _, _ = val
+
+                      tail = new_array_pattern_tail nil, nil, nil, nil
+                      result = new_array_pattern const, nil, tail, const.line
+                    }
+                | p_const p_lbracket p_args rbracket
+                    {
+                      const, _, pre_arg, _ = val
+
+                      pop_pktbl
+                      result = new_array_pattern const, nil, pre_arg, const.line
+                    }
+                | p_const p_lbracket p_kwargs rbracket
+                    {
+                      const, _, kwargs, _ = val
+
+                      result = new_hash_pattern const, kwargs, const.line
+                    }
+                | p_const tLBRACK2 rbracket
+                    {
+                      const, _, _ = val
+
+                      tail = new_array_pattern_tail nil, nil, nil, nil
+                      result = new_array_pattern const, nil, tail, const.line
+                    }
+                | tLBRACK { push_pktbl } p_args rbracket
+                    {
+                      _, _, pat, _ = val
+
+                      pop_pktbl
+                      result = new_array_pattern nil, nil, pat, pat.line
+                    }
+                | tLBRACK rbracket
+                    {
+                      (_, line), _ = val
+
+                      result = s(:array_pat).line line
+                    }
+                | tLBRACE
+                    {
+                      push_pktbl
+                      result = self.in_kwarg
+                      self.in_kwarg = false
+                    }
+                    p_kwargs rbrace
+                    {
+                      _, in_kwarg, kwargs, _ = val
+
+                      pop_pktbl
+                      self.in_kwarg = in_kwarg
+
+                      result = new_hash_pattern(nil, kwargs, kwargs.line)
+                    }
+                | tLBRACE rbrace
+                    {
+                      (_, line), _ = val
+
+                      tail = new_hash_pattern_tail nil, nil, line
+                      result = new_hash_pattern nil, tail, line
+                    }
+                | tLPAREN { push_pktbl } p_expr tRPAREN
+                    {
+                      _, _, expr, _ = val
+
+                      pop_pktbl
+                      result = expr
+                    }
+
+          p_args: p_expr
+                    {
+                      expr, = val
+
+                      ary = s(:array_TAIL, expr).line expr.line
+                      result = new_array_pattern_tail(ary, nil, nil, nil).line expr.line
+                    }
+                | p_args_head
+                    {
+                      head, = val
+
+                      result = new_array_pattern_tail head, true, nil, nil
+                    }
+                | p_args_head p_arg
+                    {
+                      head, tail = val
+
+                      both = array_pat_concat head, tail
+
+                      result = new_array_pattern_tail both, nil, nil, nil
+                      result.line head.line
+                    }
+                | p_args_head tSTAR tIDENTIFIER
+                    {
+                      head, _, (id, _line) = val
+
+                      result = new_array_pattern_tail head, true, id.to_sym, nil
+                      result.line head.line
+                    }
+                | p_args_head tSTAR tIDENTIFIER tCOMMA p_args_post
+                    {
+                      head, _, (id, _line), _, post = val
+
+                      result = new_array_pattern_tail head, true, id.to_sym, post
+                      result.line head.line
+                    }
+                | p_args_head tSTAR
+                    {
+                      expr, _ = val
+
+                      result = new_array_pattern_tail(expr, true, nil, nil).line expr.line
+                    }
+                | p_args_head tSTAR tCOMMA p_args_post
+                    {
+                      head, _, _, post = val
+
+                      result = new_array_pattern_tail(head, true, nil, post).line head.line
+                    }
+                | p_args_tail
+
+     p_args_head: p_arg tCOMMA
+                    {
+                      arg, _ = val
+                      result = arg
+                    }
+                | p_args_head p_arg tCOMMA
+                    {
+                      head, tail, _ = val
+
+                      result = s(:PATTERN, *head.sexp_body, *tail.sexp_body)
+                      result.line head.line
+                    }
+
+     p_args_tail: tSTAR tIDENTIFIER
+                    {
+                      _, (id, line) = val
+
+                      result = new_array_pattern_tail nil, true, id.to_sym, nil
+                      result.line line
+                    }
+                | tSTAR tIDENTIFIER tCOMMA p_args_post
+                    {
+                      _, (id, line), _, rhs = val
+
+                      result = new_array_pattern_tail nil, true, id.to_sym, rhs
+                      result.line line
+                    }
+                | tSTAR
+                    {
+                      (_, line), = val
+
+                      result = new_array_pattern_tail nil, true, nil, nil
+                      result.line line
+                    }
+                | tSTAR tCOMMA p_args_post
+                    {
+                      (_, line), _, args = val
+
+                      result = new_array_pattern_tail nil, true, nil, args
+                      result.line line
+                    }
+
+     p_args_post: p_arg
+                | p_args_post tCOMMA p_arg
+                    {
+                      lhs, _, rhs = val
+
+                      result = array_pat_concat lhs, rhs
+                    }
+
+           p_arg: p_expr
+                    {
+                      expr, = val
+                      expr = s(:array_TAIL, expr).line expr.line unless
+                        expr.sexp_type == :array_TAIL
+                      result = expr
+                    }
+
+        p_kwargs: p_kwarg tCOMMA p_kwrest
+                    {
+                      kw_arg, _, rest = val
+                      # TODO? new_unique_key_hash(p, $1, &@$)
+                      result = new_hash_pattern_tail kw_arg, rest, kw_arg.line
+                    }
+                | p_kwarg
+                    {
+                      kwarg, = val
+                      # TODO? new_unique_key_hash(p, $1, &@$)
+                      result = new_hash_pattern_tail kwarg, nil, kwarg.line
+                    }
+                | p_kwarg tCOMMA
+                    {
+                      kwarg, _ = val
+                      # TODO? new_unique_key_hash(p, $1, &@$)
+                      result = new_hash_pattern_tail kwarg, nil, kwarg.line
+                    }
+                | p_kwrest
+                    {
+                      rest, = val
+
+                      result = new_hash_pattern_tail nil, rest, rest.line
+                    }
+                | p_kwarg tCOMMA p_kwnorest
+                    {
+                      kwarg, _, norest = val
+
+                      # TODO? new_unique_key_hash(p, $1, &@$)
+                      result = new_hash_pattern_tail kwarg, norest, kwarg.line
+                    }
+                | p_kwnorest
+                    {
+                      norest, = val
+
+                      result = new_hash_pattern_tail nil, norest, norest.line
+                    }
+
+         p_kwarg: p_kw # TODO? rb_ary_new_from_args(1, $1)
+                | p_kwarg tCOMMA p_kw
+                    {
+                      kwarg, _, kw = val
+                      kwarg.concat kw.sexp_body
+                      result = kwarg
+                    }
+
+            p_kw: p_kw_label p_expr
+                    {
+                      # TODO: error_duplicate_pattern_key(p, get_id($1), &@1);
+                      lhs, rhs = val
+
+                      result = s(:PAIR, lhs, rhs).line lhs.line
+                    }
+                | p_kw_label
+                    {
+                      lhs, = val
+
+                      # TODO: error_duplicate_pattern_variable(p, get_id($1), &@1);
+
+                      # TODO: if ($1 && !is_local_id(get_id($1))) {
+                      #     yyerror1(&@1, "key must be valid as local variables");
+                      # }
+
+                      # $$ = list_append(p, NEW_LIST(NEW_LIT(ID2SYM($1), &@$), &@$),
+                      #                     assignable(p, $1, 0, &@$));
+
+
+                      case lhs.sexp_type
+                      when :lit then
+                        assignable [lhs.value, lhs.line]
+                      else
+                        # TODO or done?
+                        debug 666
+                      end
+
+                      # TODO PAIR -> LIST ?
+                      result = s(:PAIR, lhs, nil).line lhs.line
+                    }
+
+      p_kw_label: tLABEL
+                    {
+                      (id, line), = val
+
+                      result = s(:lit, id.to_sym).line line
+                    }
+
+        p_kwrest: kwrest_mark tIDENTIFIER
+                    {
+                      _, (id, line) = val
+
+                      name = id.to_sym
+                      self.assignable [name, line]
+                      result = s(:kwrest, :"**#{name}").line line
+                    }
+                | kwrest_mark
+                    {
+                      (_, line), = val
+
+                      result = s(:kwrest, :"**").line line
+                    }
+
+      p_kwnorest: kwrest_mark kNIL
+                    {
+                      (_, line), _ = val
+
+                      # TODO: or s(:norest)? s(:**nil)?
+                      result = s(:kwrest, :"**nil").line line
+                    }
+
+         p_value: p_primitive
+                | p_primitive tDOT2 p_primitive
+                    {
+                      lhs, _, rhs = val
+
+                      lhs = value_expr lhs
+                      rhs = value_expr rhs
+
+                      result = s(:dot2, lhs, rhs).line lhs.line
+                    }
+                | p_primitive tDOT3 p_primitive
+                    {
+                      lhs, _, rhs = val
+
+                      lhs = value_expr lhs
+                      rhs = value_expr rhs
+
+                      result = s(:dot3, lhs, rhs).line lhs.line
+                    }
+                | p_primitive tDOT2
+                    {
+                      v1, _ = val
+
+                      result = s(:dot2, v1, nil).line v1.line
+                    }
+                | p_primitive tDOT3
+                    {
+                      v1, _ = val
+
+                      result = s(:dot3, v1, nil).line v1.line
+                    }
+                | p_variable
+                | p_var_ref
+                | p_const
+                | tBDOT2 p_primitive
+                    {
+                      _, v1 = val
+
+                      result = s(:dot2, nil, v1).line v1.line
+                    }
+                | tBDOT3 p_primitive
+                    {
+                      _, v1 = val
+
+                      result = s(:dot3, nil, v1).line v1.line
+                    }
+
+     p_primitive: literal
+                | strings
+                | xstring
+                | regexp
+                | words
+                | qwords
+                | symbols
+                | qsymbols
+                | keyword_variable
+                    {
+                      # TODO? if (!($$ = gettable(p, $1, &@$))) $$ = NEW_BEGIN(0, &@$);
+                      var, = val
+
+                      result = var
+                    }
+                | lambda
+
+      p_variable: tIDENTIFIER
+                    {
+                      (id, line), = val
+
+                      # TODO: error_duplicate_pattern_variable(p, $1, &@1);
+                      # TODO: assignable(p, $1, 0, &@$);
+                      result = s(:lvar, id.to_sym).line line
+                    }
+
+       p_var_ref: tCARET tIDENTIFIER
+                    {
+                      _, (id, line) = val
+
+                      # TODO: check id against env for lvar or dvar
+
+                      result = s(:lvar, id.to_sym).line line
+                    }
+
+         p_const: tCOLON3 cname
+                    {
+                      _, (id, line) = val
+                      result = s(:colon3, id.to_sym).line line
+                    }
+                | p_const tCOLON2 cname
+                    {
+                      lhs, _, (id, _line) = val
+
+                      l = lhs.line
+                      result = s(:const, s(:colon2, lhs, id.to_sym).line(l)).line l
+                    }
+                | tCONSTANT
+                    {
+                      # TODO $$ = gettable(p, $1, &@$);
+                      (id, line), = val
+                      result = s(:const, id.to_sym).line line
+                    }
+######################################################################
 
       opt_rescue: k_rescue exc_list exc_var then compstmt opt_rescue
                     {
@@ -2005,17 +2545,10 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          literal: numeric
                     {
-                      line = lexer.lineno
-                      result = s(:lit, val[0])
-                      result.line = line
+                      (lit, line), = val
+                      result = s(:lit, lit).line line
                     }
                 | symbol
-                    {
-                      line = lexer.lineno
-                      result = s(:lit, val[0])
-                      result.line = line
-                    }
-                | dsym
 
          strings: string
                     {
@@ -2026,7 +2559,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
           string: tCHAR
                     {
-                      debug20 23, val, result
+                      debug 37
                     }
                 | string1
                 | string string1
@@ -2036,11 +2569,11 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          string1: tSTRING_BEG string_contents tSTRING_END
                     {
-                      _, str, (_, func) = val
+                      (_, line), str, (_, func) = val
 
-                      str = dedent str if func =~ RubyLexer::STR_FUNC_ICNTNT
+                      str = dedent str if func =~ RubyLexer::STR_FUNC_DEDENT
 
-                      result = str
+                      result = str.line line
                     }
                 | tSTRING
                     {
@@ -2060,11 +2593,15 @@ opt_block_args_tail: tCOMMA block_args_tail
 
            words: tWORDS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array).line lexer.lineno
+                      (_, line), _, _ = val
+
+                      result = s(:array).line line
                     }
                 | tWORDS_BEG word_list tSTRING_END
                     {
-                      result = val[1]
+                      (_, line), list, _ = val
+
+                      result = list.line line
                     }
 
        word_list: none
@@ -2084,18 +2621,20 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          symbols: tSYMBOLS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array).line lexer.lineno
+                      (_, line), _, _ = val
+
+                      result = s(:array).line line
                     }
-                | tSYMBOLS_BEG { result = lexer.lineno } symbol_list tSTRING_END
+                | tSYMBOLS_BEG symbol_list tSTRING_END
                     {
-                      _, line, list, _, = val
-                      list.line = line
+                      (_, line), list, _, = val
+                      list.line line
                       result = list
                     }
 
      symbol_list: none
                     {
-                      result = new_symbol_list.line lexer.lineno
+                      result = new_symbol_list
                     }
                 | symbol_list word tSPACE
                     {
@@ -2105,20 +2644,28 @@ opt_block_args_tail: tCOMMA block_args_tail
 
           qwords: tQWORDS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array).line lexer.lineno
+                      (_, line), _, _ = val
+
+                      result = s(:array).line line
                     }
                 | tQWORDS_BEG qword_list tSTRING_END
                     {
-                      result = val[1]
+                      (_, line), list, _ = val
+
+                      result = list.line line
                     }
 
         qsymbols: tQSYMBOLS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array).line lexer.lineno # FIX
+                      (_, line), _, _ = val
+
+                      result = s(:array).line line
                     }
                 | tQSYMBOLS_BEG qsym_list tSTRING_END
                     {
-                      result = val[1]
+                      (_, line), list, _ = val
+
+                      result = list.line line
                     }
 
       qword_list: none
@@ -2141,7 +2688,8 @@ opt_block_args_tail: tCOMMA block_args_tail
 
  string_contents: none
                     {
-                      result = s(:str, "").line lexer.lineno
+                      line = prev_value_to_lineno _values.last
+                      result = s(:str, +"").line line
                     }
                 | string_contents string_content
                     {
@@ -2216,8 +2764,8 @@ regexp_contents: none
                       lexer.brace_nest  = brace_nest
                       lexer.string_nest = string_nest
 
-                      lexer.cmdarg.pop
                       lexer.cond.pop
+                      lexer.cmdarg.pop
 
                       lexer.lex_state = oldlex_state
 
@@ -2232,29 +2780,49 @@ regexp_contents: none
                       when nil then
                         result = s(:evstr).line line
                       else
-                        debug20 25
+                        debug 38
                         raise "unknown string body: #{stmt.inspect}"
                       end
                     }
 
-     string_dvar: tGVAR { result = s(:gvar, val[0].to_sym).line lexer.lineno }
-                | tIVAR { result = s(:ivar, val[0].to_sym).line lexer.lineno }
-                | tCVAR { result = s(:cvar, val[0].to_sym).line lexer.lineno }
+     string_dvar: tGVAR
+                    {
+                      (id, line), = val
+                      result = s(:gvar, id.to_sym).line line
+                    }
+                | tIVAR
+                    {
+                      (id, line), = val
+                      result = s(:ivar, id.to_sym).line line
+                    }
+                | tCVAR
+                    {
+                      (id, line), = val
+                      result = s(:cvar, id.to_sym).line line
+                    }
                 | backref
 
-          symbol: tSYMBEG sym
+          symbol: ssym
+                | dsym
+
+            ssym: tSYMBEG sym
                     {
+                      _, (id, line) = val
+
                       lexer.lex_state = EXPR_END
-                      result = val[1].to_sym
+                      result = s(:lit, id.to_sym).line line
                     }
                 | tSYMBOL
                     {
-                      result = val[0].to_sym
+                      (id, line), = val
+
+                      lexer.lex_state = EXPR_END
+                      result = s(:lit, id.to_sym).line line
                     }
 
              sym: fname | tIVAR | tGVAR | tCVAR
 
-            dsym: tSYMBEG xstring_contents tSTRING_END
+            dsym: tSYMBEG string_contents tSTRING_END
                     {
                       _, result, _ = val
 
@@ -2270,35 +2838,22 @@ regexp_contents: none
                       when :evstr then
                         result = s(:dsym, "", result).line result.line
                       else
-                        debug20 26, val, result
+                        debug 39
                       end
                     }
 
-#if V == 20
-         numeric: tINTEGER
-                | tFLOAT
-                | tUMINUS_NUM tINTEGER =tLOWEST
-#else
          numeric: simple_numeric
-                | tUMINUS_NUM simple_numeric
-#endif
-                    {
-                      result = -val[1] # TODO: pt_testcase
-#if V == 20
-                    }
-                | tUMINUS_NUM tFLOAT   =tLOWEST
+                | tUMINUS_NUM simple_numeric            =tLOWEST
                     {
-                      result = -val[1] # TODO: pt_testcase
-#endif
+                      _, (num, line) = val
+                      result = [-num, line]
                     }
 
-#if V >= 21
   simple_numeric: tINTEGER
                 | tFLOAT
                 | tRATIONAL
                 | tIMAGINARY
 
-#endif
    user_variable: tIDENTIFIER
                 | tIVAR
                 | tGVAR
@@ -2324,8 +2879,10 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
 
          var_ref: user_variable
                     {
-                      var = val[0]
+                      raise "NO: #{val.inspect}" if Sexp === val.first
+                      (var, line), = val
                       result = Sexp === var ? var : self.gettable(var)
+                      result.line line
                     }
                 | keyword_variable
                     {
@@ -2340,11 +2897,19 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                 | keyword_variable
                     {
                       result = self.assignable val[0]
-                      debug20 29, val, result
+                      debug 40
                     }
 
-         backref: tNTH_REF  { result = s(:nth_ref,  val[0]).line lexer.lineno }
-                | tBACK_REF { result = s(:back_ref, val[0]).line lexer.lineno }
+         backref: tNTH_REF
+                    {
+                      (ref, line), = val
+                      result = s(:nth_ref, ref).line line
+                    }
+                | tBACK_REF
+                    {
+                      (ref, line), = val
+                      result = s(:back_ref, ref).line line
+                    }
 
       superclass: tLT
                     {
@@ -2362,9 +2927,15 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
 
        f_arglist: tLPAREN2 f_args rparen
                     {
-                      result = val[1]
-                      self.lexer.lex_state = EXPR_BEG
-                      self.lexer.command_start = true
+                      result = end_args val
+                    }
+                | tLPAREN2 f_arg tCOMMA args_forward rparen
+                    {
+                      result = end_args val
+                    }
+                | tLPAREN2 args_forward rparen
+                    {
+                      result = end_args val
                     }
                 |   {
                       result = self.in_kwarg
@@ -2373,12 +2944,7 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                     }
                     f_args term
                     {
-                      kwarg, args, _ = val
-
-                      self.in_kwarg = kwarg
-                      result = args
-                      lexer.lex_state     = EXPR_BEG
-                      lexer.command_start = true
+                      result = end_args val
                     }
 
        args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
@@ -2393,6 +2959,10 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                     {
                       result = args val
                     }
+                | f_no_kwarg opt_f_block_arg
+                    {
+                      result = args val
+                    }
                 | f_block_arg
 
    opt_args_tail: tCOMMA args_tail
@@ -2463,6 +3033,12 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                 |
                     {
                       result = args val
+                      # result.line lexer.lineno
+                    }
+
+    args_forward: tBDOT3
+                    {
+                      result = s(:forward_args).line lexer.lineno
                     }
 
        f_bad_arg: tCONSTANT
@@ -2485,41 +3061,26 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
       f_norm_arg: f_bad_arg
                 | tIDENTIFIER
                     {
-                      identifier = val[0].to_sym
+                      (id, line), = val
+                      identifier = id.to_sym
                       self.env[identifier] = :lvar
 
-                      result = identifier
+                      result = [identifier, line]
                     }
 
-#if V >= 22
       f_arg_asgn: f_norm_arg
 
       f_arg_item: f_arg_asgn
                 | tLPAREN f_margs rparen
                     {
-                      result = val[1]
-                    }
-#else
-      f_arg_item: f_norm_arg
-                | tLPAREN f_margs rparen
-                    {
-                      result = val[1]
+                      _, margs, _ = val
+
+                      result = margs
                     }
-#endif
 
            f_arg: f_arg_item
                     {
-                      arg, = val
-
-                      case arg
-                      when Symbol then
-                        result = s(:args, arg).line lexer.lineno
-                      when Sexp then
-                        result = arg
-                      else
-                        debug20 32
-                        raise "Unknown f_arg type: #{val.inspect}"
-                      end
+                      result = new_arg val
                     }
                 | f_arg tCOMMA f_arg_item
                     {
@@ -2531,16 +3092,12 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                         result = s(:args, list).line list.line
                       end
 
-                      result << item
+                      result << (Sexp === item ? item : item.first)
                     }
 
-#if V == 20
-            f_kw: tLABEL arg_value
-#else
          f_label: tLABEL
 
             f_kw: f_label arg_value
-#endif
                     {
                       # TODO: new_kw_arg
                       (label, line), arg = val
@@ -2551,7 +3108,6 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                       kwarg  = s(:kwarg, identifier, arg).line line
                       result = s(:array, kwarg).line line
                     }
-#if V >= 21
                 | f_label
                     {
                       (label, line), = val
@@ -2561,13 +3117,8 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
 
                       result = s(:array, s(:kwarg, id).line(line)).line line
                     }
-#endif
 
-#if V == 20
-      f_block_kw: tLABEL primary_value
-#else
       f_block_kw: f_label primary_value
-#endif
                     {
                       # TODO: new_kw_arg
                       (label, line), expr = val
@@ -2576,7 +3127,6 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
 
                       result = s(:array, s(:kwarg, id, expr).line(line)).line line
                     }
-#if V >= 21
                 | f_label
                     {
                       # TODO: new_kw_arg
@@ -2586,7 +3136,6 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
 
                       result = s(:array, s(:kwarg, id).line(line)).line line
                     }
-#endif
 
    f_block_kwarg: f_block_kw
                 | f_block_kwarg tCOMMA f_block_kw
@@ -2604,38 +3153,37 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
      kwrest_mark: tPOW
                 | tDSTAR
 
+      f_no_kwarg: kwrest_mark kNIL
+                    {
+                      result = :"**nil"
+                    }
+
         f_kwrest: kwrest_mark tIDENTIFIER
                     {
-                      name = val[1].to_sym
-                      self.assignable name
-                      result = :"**#{name}"
+                      _, (id, line) = val
+
+                      name = id.to_sym
+                      self.assignable [name, line]
+                      result = [:"**#{name}", line]
                     }
                 | kwrest_mark
                     {
-                      result = :"**"
+                      id = :"**"
+                      self.env[id] = :lvar # TODO: needed?!?
+                      result = [id, lexer.lineno] # TODO: tPOW/tDSTAR include lineno
                     }
 
-#if V == 20
-           f_opt: tIDENTIFIER tEQL arg_value
-#elif V == 21
-           f_opt: f_norm_arg tEQL arg_value
-#else
            f_opt: f_arg_asgn tEQL arg_value
-#endif
                     {
-                      result = self.assignable val[0], val[2]
+                      lhs, _, rhs = val
+                      result = self.assignable lhs, rhs
                       # TODO: detect duplicate names
                     }
 
-#if V == 20
-     f_block_opt: tIDENTIFIER tEQL primary_value
-#elif V == 21
-     f_block_opt: f_norm_arg tEQL primary_value
-#else
      f_block_opt: f_arg_asgn tEQL primary_value
-#endif
                     {
-                      result = self.assignable val[0], val[2]
+                      lhs, _, rhs = val
+                      result = self.assignable lhs, rhs
                     }
 
   f_block_optarg: f_block_opt
@@ -2665,30 +3213,33 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
       f_rest_arg: restarg_mark tIDENTIFIER
                     {
                       # TODO: differs from parse.y - needs tests
-                      name = val[1].to_sym
-                      self.assignable name
-                      result = :"*#{name}"
+                      _, (id, line) = val
+                      name = id.to_sym
+                      self.assignable [name, line]
+                      result = [:"*#{name}", line]
                     }
                 | restarg_mark
                     {
                       name = :"*"
                       self.env[name] = :lvar
-                      result = name
+                      result = [name, lexer.lineno] # FIX: tSTAR to include lineno
                     }
 
      blkarg_mark: tAMPER2 | tAMPER
 
      f_block_arg: blkarg_mark tIDENTIFIER
                     {
-                      identifier = val[1].to_sym
+                      _, (id, line) = val
+                      identifier = id.to_sym
 
                       self.env[identifier] = :lvar
-                      result = "&#{identifier}".to_sym
+                      result = ["&#{identifier}".to_sym, line]
                     }
 
  opt_f_block_arg: tCOMMA f_block_arg
                     {
-                      result = val[1]
+                      _, arg = val
+                      result = arg
                     }
                 |
                     {
@@ -2735,14 +3286,14 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                       lit = s(:lit, label.to_sym).line line
                       result = s(:array, lit, arg).line line
                     }
-#if V >= 22
                 | tSTRING_BEG string_contents tLABEL_END arg_value
                     {
-                      _, sym, _, value = val
+                      (_, line), sym, _, value = val
+
                       sym.sexp_type = :dsym
-                      result = s(:array, sym, value).line sym.line
+
+                      result = s(:array, sym, value).line line
                     }
-#endif
                 | tDSTAR arg_value
                     {
                       _, arg = val
@@ -2755,9 +3306,7 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
       operation3: tIDENTIFIER | tFID | op
     dot_or_colon: tDOT | tCOLON2
          call_op: tDOT
-#if V >= 23
                 | tLONELY # TODO: rename tANDDOT?
-#endif
 
         call_op2: call_op
                 | tCOLON2
@@ -2766,6 +3315,7 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
           opt_nl:  | tNL
           rparen: opt_nl tRPAREN
         rbracket: opt_nl tRBRACK
+          rbrace: opt_nl tRCURLY
          trailer:  | tNL | tCOMMA
 
             term: tSEMI { yyerrok }