ruby_parser 3.15.0 → 3.18.0

data/lib/ruby26_parser.y

@@ -18,10 +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
+      tLAMBEG tDSTAR tCHAR tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DEND
       tRATIONAL tIMAGINARY
       tLABEL_END
        tLONELY
+       tBDOT2 tBDOT3
 
 preclow
   nonassoc tLOWEST
@@ -33,7 +34,7 @@ preclow
   right    tEQL tOP_ASGN
   left     kRESCUE_MOD
   right    tEH tCOLON
-  nonassoc tDOT2 tDOT3
+  nonassoc tDOT2 tDOT3 tBDOT2 tBDOT3
   left     tOROP
   left     tANDOP
   nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
@@ -56,6 +57,9 @@ rule
                     top_compstmt
                     {
                       result = new_compstmt val
+
+                      lexer.cond.pop # local_pop
+                      lexer.cmdarg.pop
                     }
 
     top_compstmt: top_stmts opt_terms
@@ -76,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
@@ -101,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
@@ -131,7 +137,7 @@ rule
                 | error stmt
                     {
                       result = val[1]
-                      debug20 2, val, result
+                      debug 12
                     }
 
    stmt_or_begin: stmt
@@ -139,6 +145,10 @@ rule
                     {
                       yyerror "BEGIN is permitted only at toplevel"
                     }
+                  begin_block
+                    {
+                      result = val[2] # wtf?
+                    }
 
             stmt: kALIAS fitem
                     {
@@ -151,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
@@ -199,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
 
@@ -239,32 +249,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
                     {
@@ -310,7 +319,7 @@ rule
                       # TODO: fix line number to tBANG... but causes BAD shift/reduce conflict
                       # REFACTOR: call_uni_op -- see parse26.y
                     }
-                | arg
+                | arg                                   =tLBRACE_ARG
 
       expr_value: expr
                     {
@@ -335,7 +344,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
                     }
 
@@ -349,15 +358,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
@@ -380,12 +389,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
@@ -395,11 +406,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
@@ -557,25 +571,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
@@ -583,58 +601,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
 
@@ -643,14 +668,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
@@ -666,16 +690,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
@@ -685,24 +710,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
                     {
@@ -723,8 +741,6 @@ rule
                 |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS | tSTAR2
                 |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tDSTAR | tBANG   | tTILDE
                 |   tUPLUS   | tUMINUS | tAREF    | tASET | tBACK_REF2
-                    # TODO: tUBANG dead?
-                |   tUBANG
 
         reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
                 | kALIAS    | kAND      | kBEGIN        | kBREAK  | kCASE
@@ -758,24 +774,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]
@@ -789,7 +801,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
@@ -798,7 +810,7 @@ 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
@@ -818,6 +830,8 @@ rule
 
                       result = s(:dot3, v1, v2).line v1.line
                     }
+
+
                 | arg tPLUS arg
                     {
                       result = new_call val[0], :+, argl(val[2])
@@ -844,8 +858,9 @@ rule
                     }
                 | tUMINUS_NUM simple_numeric tPOW arg
                     {
-                      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)), :"-@")
 
                     }
                 | tUPLUS arg
@@ -944,12 +959,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)
                     }
@@ -1140,8 +1155,9 @@ rule
                 | backref
                 | tFID
                     {
-                      msg, = val
+                      (msg, line), = val
                       result = new_call nil, msg.to_sym
+                      result.line line
                     }
                 | k_begin
                     {
@@ -1183,15 +1199,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
                     {
@@ -1238,7 +1254,7 @@ rule
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      debug20 14, val, result
+                      debug 20
                     }
                 | fcall brace_block
                     {
@@ -1256,9 +1272,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
                     {
@@ -1301,7 +1318,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
@@ -1311,7 +1327,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
                     {
@@ -1332,7 +1348,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
                     {
@@ -1340,7 +1356,6 @@ rule
                     }
                     cpath
                     {
-                      self.comments.push self.lexer.comments
                       yyerror "module definition in method body" if
                         self.in_def or self.in_single > 0
 
@@ -1350,7 +1365,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
                     {
@@ -1360,21 +1375,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
                     {
@@ -1382,7 +1393,7 @@ rule
                     }
                     fname
                     {
-                      result = [self.in_def, lexer.lineno]
+                      result = self.in_def
 
                       self.in_single += 1 # TODO: remove?
 
@@ -1392,13 +1403,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
@@ -1409,7 +1425,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
                     {
@@ -1446,8 +1462,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
@@ -1508,51 +1533,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
@@ -1569,8 +1585,8 @@ rule
                     }
                 | f_block_arg
                     {
-                      line = lexer.lineno
-                      result = call_args val # TODO: push line down
+                      (id, line), = val
+                      result = call_args [id]
                       result.line line
                     }
 
@@ -1679,13 +1695,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
@@ -1697,14 +1713,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
                     }
 
@@ -1739,23 +1755,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
@@ -1764,7 +1785,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
@@ -1772,28 +1793,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
                     {
@@ -1826,7 +1848,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       _, line, body, _ = val
 
                       result = body
-                      result.line = line
+                      result.line line
 
                       self.env.unextend
                     }
@@ -1840,7 +1862,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       _, line, body, _ = val
 
                       result = body
-                      result.line = line
+                      result.line line
 
                       self.env.unextend
                     }
@@ -1869,14 +1891,39 @@ 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]
                     }
 
@@ -1922,17 +1969,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
                     {
@@ -1943,7 +1983,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
           string: tCHAR
                     {
-                      debug20 23, val, result
+                      debug 37
                     }
                 | string1
                 | string string1
@@ -1953,11 +1993,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
                     {
@@ -1977,11 +2017,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
@@ -2001,18 +2045,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
                     {
@@ -2022,20 +2068,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
@@ -2058,7 +2112,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
                     {
@@ -2133,8 +2188,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
 
@@ -2149,29 +2204,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
 
@@ -2187,14 +2262,15 @@ regexp_contents: none
                       when :evstr then
                         result = s(:dsym, "", result).line result.line
                       else
-                        debug20 26, val, result
+                        debug 39
                       end
                     }
 
          numeric: simple_numeric
-                | tUMINUS_NUM simple_numeric
+                | tUMINUS_NUM simple_numeric            =tLOWEST
                     {
-                      result = -val[1] # TODO: pt_testcase
+                      _, (num, line) = val
+                      result = [-num, line]
                     }
 
   simple_numeric: tINTEGER
@@ -2227,8 +2303,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
                     {
@@ -2243,11 +2321,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
                     {
@@ -2265,9 +2351,7 @@ 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
                     }
                 |   {
                       result = self.in_kwarg
@@ -2276,12 +2360,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
@@ -2366,8 +2445,10 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                 |
                     {
                       result = args val
+                      # result.line lexer.lineno
                     }
 
+
        f_bad_arg: tCONSTANT
                     {
                       yyerror "formal argument cannot be a constant"
@@ -2388,10 +2469,11 @@ 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]
                     }
 
       f_arg_asgn: f_norm_arg
@@ -2399,22 +2481,14 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
       f_arg_item: f_arg_asgn
                 | tLPAREN f_margs rparen
                     {
-                      result = val[1]
+                      _, margs, _ = val
+
+                      result = margs
                     }
 
            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
                     {
@@ -2426,7 +2500,7 @@ 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)
                     }
 
          f_label: tLABEL
@@ -2487,26 +2561,33 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
      kwrest_mark: tPOW
                 | tDSTAR
 
+
         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
                     }
 
            f_opt: f_arg_asgn tEQL arg_value
                     {
-                      result = self.assignable val[0], val[2]
+                      lhs, _, rhs = val
+                      result = self.assignable lhs, rhs
                       # TODO: detect duplicate names
                     }
 
      f_block_opt: f_arg_asgn tEQL primary_value
                     {
-                      result = self.assignable val[0], val[2]
+                      lhs, _, rhs = val
+                      result = self.assignable lhs, rhs
                     }
 
   f_block_optarg: f_block_opt
@@ -2536,30 +2617,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
                     }
                 |
                     {
@@ -2608,9 +2692,11 @@ keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
                     }
                 | 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
                     }
                 | tDSTAR arg_value
                     {