ruby_parser 3.13.0 → 3.15.0

data/lib/ruby25_parser.y

@@ -23,35 +23,35 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       tLABEL_END
        tLONELY
 
-prechigh
-  right    tBANG tTILDE tUPLUS
-  right    tPOW
-  right    tUMINUS_NUM tUMINUS
-  left     tSTAR2 tDIVIDE tPERCENT
-  left     tPLUS tMINUS
-  left     tLSHFT tRSHFT
-  left     tAMPER2
-  left     tPIPE tCARET
-  left     tGT tGEQ tLT tLEQ
-  nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
-  left     tANDOP
-  left     tOROP
-  nonassoc tDOT2 tDOT3
-  right    tEH tCOLON
-  left     kRESCUE_MOD
-  right    tEQL tOP_ASGN
-  nonassoc kDEFINED
-  right    kNOT
-  left     kOR kAND
-  nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
-  nonassoc tLBRACE_ARG
-  nonassoc tLOWEST
 preclow
+  nonassoc tLOWEST
+  nonassoc tLBRACE_ARG
+  nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
+  left     kOR kAND
+  right    kNOT
+  nonassoc kDEFINED
+  right    tEQL tOP_ASGN
+  left     kRESCUE_MOD
+  right    tEH tCOLON
+  nonassoc tDOT2 tDOT3
+  left     tOROP
+  left     tANDOP
+  nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
+  left     tGT tGEQ tLT tLEQ
+  left     tPIPE tCARET
+  left     tAMPER2
+  left     tLSHFT tRSHFT
+  left     tPLUS tMINUS
+  left     tSTAR2 tDIVIDE tPERCENT # TODO: tSTAR2 -> tMULT
+  right    tUMINUS_NUM tUMINUS
+  right    tPOW
+  right    tBANG tTILDE tUPLUS
+prechigh
 
 rule
 
          program:   {
-                      self.lexer.lex_state = :expr_beg
+                      self.lexer.lex_state = EXPR_BEG
                     }
                     top_compstmt
                     {
@@ -60,7 +60,8 @@ rule
 
     top_compstmt: top_stmts opt_terms
                     {
-                      result = val[0]
+                      stmt, _ = val
+                      result = stmt
                     }
 
        top_stmts: none
@@ -72,14 +73,6 @@ rule
                 | error top_stmt
 
         top_stmt: stmt
-                    {
-                      result = val[0]
-
-                      # TODO: remove once I have more confidence this is fixed
-                      # result.each_of_type :call_args do |s|
-                      #   debug20 666, s, result
-                      # end
-                    }
                 | klBEGIN
                     {
                       if (self.in_def || self.in_single > 0) then
@@ -90,14 +83,19 @@ rule
                     }
                     begin_block
                     {
-                      _, _, block = val
-                      result = block
+                      (_, lineno), _, iter = val
+                      iter.line lineno
+
+                      (_, preexe,) = iter
+                      preexe.line lineno
+
+                      result = iter
                     }
 
-     begin_block: tLCURLY top_compstmt tRCURLY
+     begin_block: tLCURLY { result = lexer.lineno } top_compstmt tRCURLY
                     {
-                      _, stmt, _ = val
-                      result = new_iter s(:preexe), 0, stmt
+                      _, line, stmt, _ = val
+                      result = new_iter s(:preexe).line(line), 0, stmt
                     }
 
         bodystmt: compstmt opt_rescue k_else
@@ -139,34 +137,27 @@ rule
    stmt_or_begin: stmt
                 | klBEGIN
                     {
-                      if (self.in_def || self.in_single > 0) then
-                        debug20 1
-                        yyerror "BEGIN in method"
-                      end
-                      self.env.extend
-                    }
-                    begin_block
-                    {
-                      _, _, stmt = val
-                      result = stmt
+                      yyerror "BEGIN is permitted only at toplevel"
                     }
 
             stmt: kALIAS fitem
                     {
-                      lexer.lex_state = :expr_fname
-                      result = self.lexer.lineno
+                      lexer.lex_state = EXPR_FNAME
                     }
                     fitem
                     {
-                      result = s(:alias, val[1], val[3]).line(val[2])
+                      (_, line), lhs, _, rhs = val
+                      result = s(:alias, lhs, rhs).line(line).line line
                     }
                 | kALIAS tGVAR tGVAR
                     {
-                      result = s(:valias, val[1].to_sym, val[2].to_sym)
+                      (_, line), lhs, rhs = val
+                      result = s(:valias, lhs.to_sym, rhs.to_sym).line line
                     }
                 | kALIAS tGVAR tBACK_REF
                     {
-                      result = s(:valias, val[1].to_sym, :"$#{val[2]}")
+                      (_, line), lhs, rhs = val
+                      result = s(:valias, lhs.to_sym, :"$#{rhs}").line line
                     }
                 | kALIAS tGVAR tNTH_REF
                     {
@@ -178,32 +169,41 @@ rule
                     }
                 | stmt kIF_MOD expr_value
                     {
-                      result = new_if val[2], val[0], nil
+                      t, _, c = val
+                      result = new_if c, t, nil
                     }
                 | stmt kUNLESS_MOD expr_value
                     {
-                      result = new_if val[2], nil, val[0]
+                      f, _, c = val
+                      result = new_if c, nil, f
                     }
                 | stmt kWHILE_MOD expr_value
                     {
-                      result = new_while val[0], val[2], true
+                      e, _, c = val
+                      result = new_while e, c, true
                     }
                 | stmt kUNTIL_MOD expr_value
                     {
-                      result = new_until val[0], val[2], true
+                      e, _, c = val
+                      result = new_until e, c, true
                     }
                 | stmt kRESCUE_MOD stmt
                     {
                       body, _, resbody = val
-                      result = new_rescue body, new_resbody(s(:array), resbody)
+
+                      resbody = new_resbody s(:array).line(resbody.line), resbody
+                      result = new_rescue body, resbody
                     }
                 | klEND tLCURLY compstmt tRCURLY
                     {
+                      (_, line), _, stmt, _ = val
+
                       if (self.in_def || self.in_single > 0) then
                         debug20 3
                         yyerror "END in method; use at_exit"
                       end
-                      result = new_iter s(:postexe), 0, val[2]
+
+                      result = new_iter s(:postexe).line(line), 0, stmt
                     }
                 | command_asgn
                 | mlhs tEQL command_call
@@ -212,7 +212,8 @@ rule
                     }
                 | lhs tEQL mrhs
                     {
-                      result = new_assign val[0], s(:svalue, val[2])
+                      lhs, _, rhs = val
+                      result = new_assign lhs, s(:svalue, rhs).line(rhs.line)
                     }
                 | mlhs tEQL mrhs_arg
                     {
@@ -234,11 +235,12 @@ rule
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
+                      result = new_op_asgn1 val
                     }
                 | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
+                      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
@@ -254,13 +256,15 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
-                      debug20 4, val, result
+                      lhs1, _, lhs2, op, rhs = val
+
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
-                      debug20 5, val, result
+                      lhs1, _, lhs2, op, rhs = val
+
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
                     }
                 | backref tOP_ASGN command_rhs
                     {
@@ -274,28 +278,37 @@ rule
                     }
                 | command_call kRESCUE_MOD stmt
                     {
-                      expr, _, resbody = val
+                      expr, (_, line), resbody = val
+
                       expr = value_expr expr
-                      result = new_rescue(expr, new_resbody(s(:array), resbody))
+                      ary  = s(:array).line line
+                      result = new_rescue(expr, new_resbody(ary, resbody))
                     }
                 | command_asgn
 
             expr: command_call
                 | expr kAND expr
                     {
-                      result = logical_op :and, val[0], val[2]
+                      lhs, _, rhs = val
+                      result = logical_op :and, lhs, rhs
                     }
                 | expr kOR expr
                     {
-                      result = logical_op :or, val[0], val[2]
+                      lhs, _, rhs = val
+                      result = logical_op :or, lhs, rhs
                     }
                 | kNOT opt_nl expr
                     {
-                      result = s(:call, val[2], :"!")
+                      (_, line), _, expr = val
+                      result = new_call(expr, :"!").line line
+                      # REFACTOR: call_uni_op
                     }
                 | tBANG command_call
                     {
-                      result = s(:call, val[1], :"!")
+                      _, cmd = val
+                      result = new_call(cmd, :"!").line cmd.line
+                      # TODO: fix line number to tBANG... but causes BAD shift/reduce conflict
+                      # REFACTOR: call_uni_op -- see parse26.y
                     }
                 | arg
 
@@ -322,7 +335,8 @@ rule
    block_command: block_call
                 | block_call call_op2 operation2 command_args
                     {
-                      result = new_call val[0], val[2].to_sym, val[3]
+                      blk, _, msg, args = val
+                      result = new_call(blk, msg.to_sym, args).line blk.line
                     }
 
  cmd_brace_block: tLBRACE_ARG
@@ -342,26 +356,32 @@ rule
 
            fcall: operation
                     {
-                      result = new_call nil, val[0].to_sym
+                      msg, = val
+                      result = new_call(nil, msg.to_sym).line lexer.lineno
                     }
 
          command: fcall command_args =tLOWEST
                     {
-                      result = val[0].concat val[1].sexp_body # REFACTOR pattern
+                      call, args = val
+                      result = call.concat args.sexp_body
                     }
                 | fcall command_args cmd_brace_block
                     {
-                      result = val[0].concat val[1].sexp_body
-                      if val[2] then
-                        block_dup_check result, val[2]
+                      call, args, block = val
 
-                        result, operation = val[2], result
+                      result = call.concat args.sexp_body
+
+                      if block then
+                        block_dup_check result, block
+
+                        result, operation = block, result
                         result.insert 1, operation
                       end
                     }
                 | primary_value call_op operation2 command_args =tLOWEST
                     {
-                      result = new_call val[0], val[2].to_sym, val[3], val[1]
+                      lhs, callop, op, args = val
+                      result = new_call lhs, op.to_sym, args, callop
                     }
                 | primary_value call_op operation2 command_args cmd_brace_block
                     {
@@ -393,7 +413,9 @@ rule
                     }
                 | kYIELD command_args
                     {
-                      result = new_yield val[1]
+                      (_, line), args = val
+                      result = new_yield args
+                      result.line line # TODO: push to new_yield
                     }
                 | k_return call_args
                     {
@@ -402,8 +424,8 @@ rule
                     }
                 | kBREAK call_args
                     {
-                      line = val[0].last
-                      result = s(:break, ret_args(val[1])).line(line)
+                      (_, line), args = val
+                      result = s(:break, ret_args(args)).line line
                     }
                 | kNEXT call_args
                     {
@@ -420,56 +442,79 @@ rule
       mlhs_inner: mlhs_basic
                 | tLPAREN mlhs_inner rparen
                     {
-                      result = s(:masgn, s(:array, val[1]))
+                      _, arg, _ = val
+                      l = arg.line
+
+                      result = s(:masgn, s(:array, arg).line(l)).line l
                     }
 
       mlhs_basic: mlhs_head
                     {
-                      result = s(:masgn, val[0])
+                      head, = val
+                      result = s(:masgn, head).line head.line
                     }
                 | mlhs_head mlhs_item
                     {
-                      result = s(:masgn, val[0] << val[1].compact)
+                      lhs, rhs = val
+                      result = s(:masgn, lhs << rhs.compact).line lhs.line
                     }
                 | mlhs_head tSTAR mlhs_node
                     {
-                      result = s(:masgn, val[0] << s(:splat, val[2]))
+                      head, _, tail = val
+                      head << s(:splat, tail).line(tail.line)
+                      result = s(:masgn, head).line head.line
                     }
                 | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
                     {
                       ary1, _, splat, _, ary2 = val
 
-                      result = list_append ary1, s(:splat, splat)
+                      result = list_append ary1, s(:splat, splat).line(splat.line)
                       result.concat ary2.sexp_body
-                      result = s(:masgn, result)
+                      result = s(:masgn, result).line result.line
                     }
                 | mlhs_head tSTAR
                     {
-                      result = s(:masgn, val[0] << s(:splat))
+                      head, _ = val
+                      l = head.line
+                      result = s(:masgn, head << s(:splat).line(l)).line l
                     }
                 | mlhs_head tSTAR tCOMMA mlhs_post
                     {
-                      ary = list_append val[0], s(:splat)
-                      ary.concat val[3].sexp_body
-                      result = s(:masgn, ary)
+                      head, _, _, post = val
+                      ary = list_append head, s(:splat).line(head.line)
+                      ary.concat post.sexp_body
+                      result = s(:masgn, ary).line ary.line
                     }
                 | tSTAR mlhs_node
                     {
-                      result = s(:masgn, s(:array, s(:splat, val[1])))
+                      _, node = val
+                      l = node.line
+                      splat  = s(:splat, node).line l
+                      ary    = s(:array, splat).line l
+                      result = s(:masgn, ary).line l
                     }
                 | tSTAR mlhs_node tCOMMA mlhs_post
                     {
-                      ary = s(:array, s(:splat, val[1]))
-                      ary.concat val[3].sexp_body
-                      result = s(:masgn, ary)
+                      _, node, _, post = val
+
+                      splat = s(:splat, node).line node.line
+                      ary = s(:array, splat).line splat.line
+                      ary.concat post.sexp_body
+                      result = s(:masgn, ary).line ary.line
                     }
                 | tSTAR
                     {
-                      result = s(:masgn, s(:array, s(:splat)))
+                      l = lexer.lineno
+                      result = s(:masgn, s(:array, s(:splat).line(l)).line(l)).line l
                     }
                 | tSTAR tCOMMA mlhs_post
                     {
-                      result = s(:masgn, s(:array, s(:splat), *val[2].sexp_body))
+                      _, _, post = val
+                      l = post.line
+
+                      splat = s(:splat).line l
+                      ary = s(:array, splat, *post.sexp_body).line l
+                      result = s(:masgn, ary).line l
                     }
 
        mlhs_item: mlhs_node
@@ -480,7 +525,8 @@ rule
 
        mlhs_head: mlhs_item tCOMMA
                     {
-                      result = s(:array, val[0])
+                      lhs, _ = val
+                      result = s(:array, lhs).line lhs.line
                     }
                 | mlhs_head mlhs_item tCOMMA
                     {
@@ -489,7 +535,8 @@ rule
 
        mlhs_post: mlhs_item
                     {
-                      result = s(:array, val[0])
+                      item, = val
+                      result = s(:array, item).line item.line
                     }
                 | mlhs_post tCOMMA mlhs_item
                     {
@@ -514,7 +561,8 @@ rule
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      recv, _, id = val
+                      result = new_attrasgn recv, id
                     }
                 | primary_value call_op tCONSTANT
                     {
@@ -527,7 +575,10 @@ rule
                         yyerror "dynamic constant assignment"
                       end
 
-                      result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
+                      expr, _, id = val
+                      l = expr.line
+
+                      result = s(:const, s(:colon2, expr, id.to_sym).line(l), nil).line l
                     }
                 | tCOLON3 tCONSTANT
                     {
@@ -536,7 +587,10 @@ rule
                         yyerror "dynamic constant assignment"
                       end
 
-                      result = s(:const, nil, s(:colon3, val[1].to_sym))
+                      _, id = val
+                      l = lexer.lineno
+
+                      result = s(:const, nil, s(:colon3, id.to_sym).line(l)).line l
                     }
                 | backref
                     {
@@ -545,24 +599,31 @@ rule
 
              lhs: user_variable
                     {
+                      line = lexer.lineno
                       result = self.assignable val[0]
+                      result.line = line
                     }
                 | keyword_variable
                     {
+                      line = lexer.lineno
                       result = self.assignable val[0]
+                      result.line = line
                       debug20 9, val, result
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket
                     {
-                      result = self.aryset val[0], val[2]
+                      lhs, _, args, _ = val
+                      result = self.aryset lhs, args
                     }
                 | primary_value call_op tIDENTIFIER # REFACTOR
                     {
-                      result = new_attrasgn val[0], val[2], val[1]
+                      lhs, op, id = val
+                      result = new_attrasgn lhs, id, op
                     }
                 | primary_value tCOLON2 tIDENTIFIER
                     {
-                      result = s(:attrasgn, val[0], :"#{val[2]}=")
+                      lhs, _, id = val
+                      result = new_attrasgn lhs, id
                     }
                 | primary_value call_op tCONSTANT # REFACTOR?
                     {
@@ -570,21 +631,27 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
+                      expr, _, id = val
+
                       if (self.in_def || self.in_single > 0) then
                         debug20 10
                         yyerror "dynamic constant assignment"
                       end
 
-                      result = s(:const, s(:colon2, val[0], val[2].to_sym))
+                      l = expr.line
+                      result = s(:const, s(:colon2, expr, id.to_sym).line(l)).line l
                     }
                 | tCOLON3 tCONSTANT
                     {
+                      _, id = val
+
                       if (self.in_def || self.in_single > 0) then
                         debug20 11
                         yyerror "dynamic constant assignment"
                       end
 
-                      result = s(:const, s(:colon3, val[1].to_sym))
+                      l = lexer.lineno
+                      result = s(:const, s(:colon3, id.to_sym).line(l)).line l
                     }
                 | backref
                     {
@@ -599,7 +666,8 @@ rule
 
            cpath: tCOLON3 cname
                     {
-                      result = s(:colon3, val[1].to_sym)
+                      _, name = val
+                      result = s(:colon3, name.to_sym).line lexer.lineno
                     }
                 | cname
                     {
@@ -607,20 +675,23 @@ rule
                     }
                 | primary_value tCOLON2 cname
                     {
-                      result = s(:colon2, val[0], val[2].to_sym)
+                      pval, _, name = val
+
+                      result = s(:colon2, pval, name.to_sym)
+                      result.line pval.line
                     }
 
            fname: tIDENTIFIER | tCONSTANT | tFID
                 | op
                     {
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = val[0]
                     }
 
                 | reswords
                     {
                       (sym, _line), = val
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = sym
                     }
 
@@ -628,7 +699,8 @@ rule
 
            fitem: fsym
                     {
-                      result = s(:lit, val[0].to_sym)
+                      id, = val
+                      result = s(:lit, id.to_sym).line lexer.lineno
                     }
                 | dsym
 
@@ -639,7 +711,7 @@ rule
                 |
                     undef_list tCOMMA
                     {
-                      lexer.lex_state = :expr_fname
+                      lexer.lex_state = EXPR_FNAME
                     }
                     fitem
                     {
@@ -651,6 +723,7 @@ 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
@@ -673,8 +746,7 @@ rule
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
                     {
-                      val[2].sexp_type = :arglist if val[2]
-                      result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
+                      result = new_op_asgn1 val
                     }
                 | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                     {
@@ -686,17 +758,27 @@ rule
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
+                      lhs, _, id, 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
                     {
-                      # TODO: assignment
-                      raise "not yet: %p" % [val]
+                      lhs1, _, lhs2, op, rhs = val
+
+                      lhs = s(:colon2, lhs1, lhs2.to_sym).line lhs1.line
+                      result = new_const_op_asgn [lhs, op, rhs]
                     }
-                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
+                | tCOLON3 tCONSTANT
                     {
-                      # TODO: assignment
-                      raise "not yet: %p" % [val]
+                      result = self.lexer.lineno
+                    }
+                    tOP_ASGN arg_rhs
+                    {
+                      _, lhs, line, op, rhs = val
+
+                      lhs = s(:colon3, lhs.to_sym).line line
+                      result = new_const_op_asgn [lhs, op, rhs]
                     }
                 | backref tOP_ASGN arg_rhs
                     {
@@ -708,18 +790,18 @@ rule
                     {
                       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
-                        result = s(:lit, (v1.last)..(v2.last))
+                        result = s(:lit, (v1.last)..(v2.last)).line v1.line
                       else
-                        result = s(:dot2, v1, v2)
+                        result = s(:dot2, v1, v2).line v1.line
                       end
                     }
                 | 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
-                        result = s(:lit, (v1.last)...(v2.last))
+                        result = s(:lit, (v1.last)...(v2.last)).line v1.line
                       else
-                        result = s(:dot3, v1, v2)
+                        result = s(:dot3, v1, v2).line v1.line
                       end
                     }
                 | arg tPLUS arg
@@ -748,7 +830,9 @@ rule
                     }
                 | tUMINUS_NUM simple_numeric tPOW arg
                     {
-                      result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
+                      lit = s(:lit, val[1]).line lexer.lineno
+                      result = new_call(new_call(lit, :"**", argl(val[3])), :"-@")
+
                     }
                 | tUPLUS arg
                     {
@@ -789,15 +873,19 @@ rule
                     }
                 | arg tMATCH arg
                     {
-                      result = new_match val[0], val[2]
+                      lhs, _, rhs = val
+                      result = new_match lhs, rhs
                     }
                 | arg tNMATCH arg
                     {
-                      result = s(:not, new_match(val[0], val[2]))
+                      lhs, _, rhs = val
+                      result = s(:not, new_match(lhs, rhs)).line lhs.line
                     }
                 | tBANG arg
                     {
-                      result = new_call val[1], :"!"
+                      _, arg = val
+                      result = new_call arg, :"!"
+                      result.line arg.line
                     }
                 | tTILDE arg
                     {
@@ -825,11 +913,13 @@ rule
                     }
                 | kDEFINED opt_nl arg
                     {
-                      result = s(:defined, val[2])
+                      (_, line), _, arg = val
+                      result = s(:defined, arg).line line
                     }
                 | arg tEH arg opt_nl tCOLON arg
                     {
-                      result = s(:if, val[0], val[2], val[5])
+                      c, _, t, _, _, f = val
+                      result = s(:if, c, t, f).line c.line
                     }
                 | primary
 
@@ -872,28 +962,25 @@ rule
          arg_rhs: arg                   =tOP_ASGN
                 | arg kRESCUE_MOD arg
                     {
-                      body, _, resbody = val
+                      body, (_, line), resbody = val
                       body    = value_expr body
                       resbody = remove_begin resbody
-                      result  = new_rescue(body, new_resbody(s(:array), resbody))
+
+                      ary = s(:array).line line
+                      result  = new_rescue(body, new_resbody(ary, resbody))
                     }
 
       paren_args: tLPAREN2 opt_call_args rparen
                     {
-                      result = val[1]
+                      _, args, _ = val
+                      result = args
                     }
 
   opt_paren_args: none
                 | paren_args
 
    opt_call_args: none
-                    {
-                      result = val[0]
-                    }
                 | call_args
-                    {
-                      result = val[0]
-                    }
                 | args tCOMMA
                     {
                       result = args val
@@ -915,17 +1002,14 @@ rule
                 | args opt_block_arg
                     {
                       result = call_args val
-                      result = self.arg_blk_pass val[0], val[1]
                     }
                 | assocs opt_block_arg
                     {
-                      result = call_args [array_to_hash(val[0])]
-                      result = self.arg_blk_pass result, val[1]
+                      result = call_args [array_to_hash(val[0]), val[1]]
                     }
                 | args tCOMMA assocs opt_block_arg
                     {
-                      result = call_args [val[0], array_to_hash(val[2])]
-                      result = self.arg_blk_pass result, val[3]
+                      result = call_args [val[0], array_to_hash(val[2]), val[3]]
                     }
                 | block_arg
                     {
@@ -933,17 +1017,45 @@ rule
                     }
 
     command_args:   {
-                      result = lexer.cmdarg.store true
+                      # parse26.y line 2200
+
+                      # If call_args starts with a open paren '(' or
+                      # '[', look-ahead reading of the letters calls
+                      # CMDARG_PUSH(0), but the push must be done
+                      # after CMDARG_PUSH(1). So this code makes them
+                      # consistent by first cancelling the premature
+                      # CMDARG_PUSH(0), doing CMDARG_PUSH(1), and
+                      # finally redoing CMDARG_PUSH(0).
+
+                      result = yychar = self.last_token_type.first
+                      lookahead = [:tLPAREN, :tLPAREN_ARG, :tLPAREN2, :tLBRACK, :tLBRACK2].include?(yychar)
+                      lexer.cmdarg.pop if lookahead
+                      lexer.cmdarg.push true
+                      lexer.cmdarg.push false if lookahead
                     }
                       call_args
                     {
-                      lexer.cmdarg.restore val[0]
-                      result = val[1]
+                      yychar, args = val
+
+                      # call_args can be followed by tLBRACE_ARG (that
+                      # does CMDARG_PUSH(0) in the lexer) but the push
+                      # must be done after CMDARG_POP() in the parser.
+                      # So this code does CMDARG_POP() to pop 0 pushed
+                      # by tLBRACE_ARG, CMDARG_POP() to pop 1 pushed
+                      # by command_args, and CMDARG_PUSH(0) to restore
+                      # back the flag set by tLBRACE_ARG.
+
+                      lookahead = [:tLBRACE_ARG].include?(yychar)
+                      lexer.cmdarg.pop if lookahead
+                      lexer.cmdarg.pop
+                      lexer.cmdarg.push false if lookahead
+                      result = args
                     }
 
        block_arg: tAMPER arg_value
                     {
-                      result = s(:block_pass, val[1])
+                      _, arg = val
+                      result = s(:block_pass, arg).line arg.line
                     }
 
    opt_block_arg: tCOMMA block_arg
@@ -954,19 +1066,27 @@ rule
 
             args: arg_value
                     {
-                      result = s(:array, val[0])
+                      arg, = val
+                      lineno = arg.line || lexer.lineno # HACK
+
+                      result = s(:array, arg).line lineno
                     }
                 | tSTAR arg_value
                     {
-                      result = s(:array, s(:splat, val[1]))
+                      _, arg = val
+                      result = s(:array, s(:splat, arg).line(arg.line)).line arg.line
                     }
                 | args tCOMMA arg_value
                     {
-                      result = self.list_append val[0], val[2]
+                      args, _, id = val
+                      result = self.list_append args, id
                     }
                 | args tCOMMA tSTAR arg_value
                     {
-                      result = self.list_append val[0], s(:splat, val[3])
+                      # TODO: the line number from tSTAR has been dropped
+                      args, _, _, id = val
+                      line = lexer.lineno
+                      result = self.list_append args, s(:splat, id).line(line)
                     }
 
         mrhs_arg: mrhs
@@ -984,11 +1104,14 @@ rule
                     }
                 | args tCOMMA tSTAR arg_value
                     {
-                      result = self.arg_concat val[0], val[3]
+                      # TODO: make all tXXXX terminals include lexer.lineno
+                      arg, _, _, splat = val
+                      result = self.arg_concat arg, splat
                     }
                 | tSTAR arg_value
                     {
-                      result = s(:splat, val[1])
+                      _, arg = val
+                      result = s(:splat, arg).line arg.line
                     }
 
          primary: literal
@@ -1003,65 +1126,65 @@ rule
                 | backref
                 | tFID
                     {
-                      result = new_call nil, val[0].to_sym
+                      msg, = val
+                      result = new_call nil, msg.to_sym
                     }
                 | k_begin
                     {
+                      lexer.cmdarg.push false
                       result = self.lexer.lineno
-                      # TODO:
-                      # $<val>1 = cmdarg_stack;
-                      # CMDARG_SET(0);
                     }
                     bodystmt k_end
                     {
-                      # TODO: CMDARG_SET($<val>1);
-                      unless val[2] then
-                        result = s(:nil)
-                      else
-                        result = s(:begin, val[2])
-                      end
-
-                      result.line = val[1]
+                      lexer.cmdarg.pop
+                      result = new_begin val
                     }
-                | tLPAREN_ARG rparen
+                | tLPAREN_ARG
                     {
-                      # TODO: lex_state = :expr_endarg in between
-                      debug20 13, val, result
+                      lexer.lex_state = EXPR_ENDARG
+                      result = lexer.lineno
                     }
-                | tLPAREN_ARG
+                    rparen
                     {
-                      result = lexer.cmdarg.store false
-                      # result = self.lexer.cmdarg.stack.dup
-                      # lexer.cmdarg.stack.replace [false] # TODO add api for these
+                      _, line, _ = val
+                      result = s(:begin).line line
                     }
+                | tLPAREN_ARG
                     stmt
                     {
-                      lexer.lex_state = :expr_endarg
+                      lexer.lex_state = EXPR_ENDARG
                     }
                     rparen
                     {
-                      _, cmdarg, stmt, _, _, = val
-                      warning "(...) interpreted as grouped expression"
-                      lexer.cmdarg.restore cmdarg
+                      _, stmt, _, _, = val
+                      # warning "(...) interpreted as grouped expression"
                       result = stmt
                     }
                 | tLPAREN compstmt tRPAREN
                     {
-                      result = val[1] || s(:nil)
+                      _, stmt, _ = val
+                      result = stmt
+                      result ||= s(:nil).line lexer.lineno
                       result.paren = true
                     }
                 | primary_value tCOLON2 tCONSTANT
                     {
-                      result = s(:colon2, val[0], val[2].to_sym)
+                      expr, _, id = val
+
+                      result = s(:colon2, expr, id.to_sym).line expr.line
                     }
                 | tCOLON3 tCONSTANT
                     {
-                      result = s(:colon3, val[1].to_sym)
+                      _, id = val
+
+                      result = s(:colon3, id.to_sym).line lexer.lineno
                     }
-                | tLBRACK aref_args tRBRACK
+                | tLBRACK { result = lexer.lineno } aref_args tRBRACK
                     {
-                      result = val[1] || s(:array)
+                      _, line, args, _ = val
+                      result = args || s(:array)
                       result.sexp_type = :array # aref_args is :args
+                      result.line line
                     }
                 | tLBRACE
                     {
@@ -1073,7 +1196,8 @@ rule
                     }
                 | k_return
                     {
-                      result = s(:return)
+                      (_, line), = val
+                      result = s(:return).line line
                     }
                 | kYIELD tLPAREN2 call_args rparen
                     {
@@ -1089,11 +1213,14 @@ rule
                     }
                 | kDEFINED opt_nl tLPAREN2 expr rparen
                     {
-                      result = s(:defined, val[3])
+                      (_, line), _, _, arg, _ = val
+
+                      result = s(:defined, arg).line line
                     }
                 | kNOT tLPAREN2 expr rparen
                     {
-                      result = s(:call, val[2], :"!")
+                      _, _, lhs, _ = val
+                      result = new_call lhs, :"!"
                     }
                 | kNOT tLPAREN2 rparen
                     {
@@ -1101,11 +1228,11 @@ rule
                     }
                 | fcall brace_block
                     {
-                      oper, iter = val[0], val[1]
-                      call = oper # FIX
+                      call, iter = val
+
                       iter.insert 1, call
                       result = iter
-                      call.line = iter.line
+                      # FIX: probably not: call.line = iter.line
                     }
                 | method_call
                 | method_call brace_block
@@ -1213,66 +1340,82 @@ rule
                     }
                 | k_def fname
                     {
-                      result = [self.in_def, self.lexer.cmdarg.stack.dup]
+                      result = self.in_def
 
-                      self.comments.push self.lexer.comments
-                      self.in_def = true
+                      self.in_def = true # group = local_push
                       self.env.extend
-                      # TODO: local->cmdargs = cmdarg_stack;
-                      # TODO: port local_push_gen and local_pop_gen
-                      lexer.cmdarg.stack.replace [false]
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
+                      self.comments.push self.lexer.comments
                     }
-                    f_arglist bodystmt k_end
+                    f_arglist bodystmt { result = lexer.lineno } k_end
                     {
-                      in_def, cmdarg = val[2]
+                      in_def = val[2]
 
                       result = new_defn val
 
-                      lexer.cmdarg.stack.replace cmdarg
+                      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
                     }
                 | k_def singleton dot_or_colon
                     {
-                      self.comments.push self.lexer.comments
-                      lexer.lex_state = :expr_fname
+                      lexer.lex_state = EXPR_FNAME
                     }
                     fname
                     {
-                      self.in_single += 1
+                      result = [self.in_def, lexer.lineno]
+
+                      self.in_single += 1 # TODO: remove?
+
+                      self.in_def = true # local_push
                       self.env.extend
-                      lexer.lex_state = :expr_endfn # force for args
-                      result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
-                      lexer.cmdarg.stack.replace [false]
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
+                      lexer.lex_state = EXPR_ENDFN|EXPR_LABEL
+                      self.comments.push self.lexer.comments
                     }
                     f_arglist bodystmt k_end
                     {
-                      line, cmdarg = val[5]
-                      result = new_defs val
-                      result[3].line line
+                      _, _recv, _, _, _name, (in_def, _lineno), _args, _body, _ = val
 
-                      lexer.cmdarg.stack.replace cmdarg
+                      result = new_defs val
 
+                      lexer.cond.pop # group = local_pop
+                      lexer.cmdarg.pop
                       self.env.unextend
+                      self.in_def = in_def
+
                       self.in_single -= 1
+
+                      # TODO: restore cur_arg ? what's cur_arg?
+
                       self.lexer.comments # we don't care about comments in the body
                     }
                 | kBREAK
                     {
-                      result = s(:break)
+                      (_, line), = val
+                      result = s(:break).line line
                     }
                 | kNEXT
                     {
-                      result = s(:next)
+                      (_, line), = val
+                      result = s(:next).line line
                     }
                 | kREDO
                     {
-                      result = s(:redo)
+                      (_, line), = val
+                      result = s(:redo).line line
                     }
                 | kRETRY
                     {
-                      result = s(:retry)
+                      (_, line), = val
+                      result = s(:retry).line line
                     }
 
    primary_value: primary
@@ -1311,7 +1454,9 @@ rule
          if_tail: opt_else
                 | k_elsif expr_value then compstmt if_tail
                     {
-                      result = s(:if, val[1], val[3], val[4])
+                      (_, line), c, _, t, rest = val
+
+                      result = s(:if, c, t, rest).line line
                     }
 
         opt_else: none
@@ -1334,7 +1479,9 @@ rule
 
      f_marg_list: f_marg
                     {
-                      result = s(:array, val[0])
+                      sym, = val
+
+                      result = s(:array, sym).line lexer.lineno
                     }
                 | f_marg_list tCOMMA f_marg
                     {
@@ -1408,7 +1555,9 @@ rule
                     }
                 | f_block_arg
                     {
-                      result = call_args val
+                      line = lexer.lineno
+                      result = call_args val # TODO: push line down
+                      result.line line
                     }
 
 opt_block_args_tail: tCOMMA block_args_tail
@@ -1439,7 +1588,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | f_arg tCOMMA
                     {
-                      result = args val
+                      result = args(val) << nil
                     }
                 | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
@@ -1491,7 +1640,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | tOROP
                     {
-                      result = s(:args)
+                      result = s(:args).line lexer.lineno
                     }
                 | tPIPE block_param opt_bv_decl tPIPE
                     {
@@ -1516,34 +1665,33 @@ opt_block_args_tail: tCOMMA block_args_tail
 
             bvar: tIDENTIFIER
                     {
-                      result = s(:shadow, val[0].to_sym)
+                      id, = val
+                      line = lexer.lineno
+                      result = s(:shadow, id.to_sym).line line
                     }
                 | f_bad_arg
 
           lambda:   {
                       self.env.extend :dynamic
-                      result = self.lexer.lineno
-
-                      result = lexer.lpar_beg
+                      result = [lexer.lineno, lexer.lpar_beg]
                       lexer.paren_nest += 1
                       lexer.lpar_beg = lexer.paren_nest
                     }
                     f_larglist
                     {
-                      result = [lexer.cmdarg.store(false), self.lexer.lineno]
+                      lexer.cmdarg.push false
                     }
                     lambda_body
                     {
-                      lpar, args, (cmdarg, lineno), body = val
+                      (line, lpar), args, _cmdarg, body = val
                       lexer.lpar_beg = lpar
 
-                      lexer.cmdarg.restore cmdarg
-                      lexer.cmdarg.lexpop
+                      lexer.cmdarg.pop
 
-                      call = new_call nil, :lambda
+                      call = s(:lambda).line line
                       result = new_iter call, args, body
-                      result.line = lineno
-                      self.env.unextend
+                      result.line = line
+                      self.env.unextend # TODO: dynapush & dynapop
                     }
 
      f_larglist: tLPAREN2 f_args opt_bv_decl rparen
@@ -1567,8 +1715,8 @@ opt_block_args_tail: tCOMMA block_args_tail
 
         do_block: k_do_block do_body kEND
                     {
-                      # TODO: maybe fix lineno to kDO's lineno?
-                      result = val[1]
+                      (_, line), iter, _ = val
+                      result = iter.line line
                     }
 
       block_call: command do_block
@@ -1582,8 +1730,10 @@ opt_block_args_tail: tCOMMA block_args_tail
 
                       val = invert_block_call val if inverted? val
 
-                      result = val[1]
-                      result.insert 1, val[0]
+                      cmd, blk = val
+
+                      result = blk
+                      result.insert 1, cmd
                     }
                 | block_call call_op2 operation2 opt_paren_args
                     {
@@ -1614,8 +1764,10 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                     paren_args
                     {
-                      args = self.call_args val[2..-1]
-                      result = val[0].concat args.sexp_body
+                      call, lineno, args = val
+
+                      result = call.concat args.sexp_body if args
+                      result.line lineno
                     }
                 | primary_value call_op operation2 opt_paren_args
                     {
@@ -1643,7 +1795,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | kSUPER
                     {
-                      result = s(:zsuper)
+                      result = s(:zsuper).line lexer.lineno
                     }
                 | primary_value tLBRACK2 opt_call_args rbracket
                     {
@@ -1692,15 +1844,15 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
 
          do_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
-                    { result = lexer.cmdarg.store(false) }
+                    { lexer.cmdarg.push false }
                     opt_block_param
                     bodystmt
                     {
-                      line, cmdarg, param, cmpstmt = val
+                      line, _cmdarg, param, cmpstmt = val
 
                       result = new_do_body param, cmpstmt, line
+                      lexer.cmdarg.pop
                       self.env.unextend
-                      lexer.cmdarg.restore cmdarg
                     }
 
        case_body: k_when
@@ -1721,7 +1873,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                       (_, line), klasses, var, _, body, rest = val
 
                       klasses ||= s(:array)
-                      klasses << new_assign(var, s(:gvar, :"$!")) if var
+                      klasses << new_assign(var, s(:gvar, :"$!").line(var.line)) if var
                       klasses.line line
 
                       result = new_resbody(klasses, body)
@@ -1734,7 +1886,8 @@ opt_block_args_tail: tCOMMA block_args_tail
 
         exc_list: arg_value
                     {
-                      result = s(:array, val[0])
+                      arg, = val
+                      result = s(:array, arg).line arg.line
                     }
                 | mrhs
                 | none
@@ -1747,26 +1900,31 @@ opt_block_args_tail: tCOMMA block_args_tail
 
       opt_ensure: k_ensure compstmt
                     {
-                      _, body = val
+                      (_, line), body = val
 
-                      result = body || s(:nil)
+                      result = body || s(:nil).line(line)
                     }
                 | none
 
          literal: numeric
                     {
+                      line = lexer.lineno
                       result = s(:lit, val[0])
+                      result.line = line
                     }
                 | symbol
                     {
+                      line = lexer.lineno
                       result = s(:lit, val[0])
+                      result.line = line
                     }
                 | dsym
 
          strings: string
                     {
-                      val[0] = s(:dstr, val[0].value) if val[0].sexp_type == :evstr
-                      result = val[0]
+                      str, = val
+                      str = s(:dstr, str.value) if str.sexp_type == :evstr
+                      result = str
                     }
 
           string: tCHAR
@@ -1781,7 +1939,11 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          string1: tSTRING_BEG string_contents tSTRING_END
                     {
-                      result = val[1]
+                      _, str, (_, func) = val
+
+                      str = dedent str if func =~ RubyLexer::STR_FUNC_ICNTNT
+
+                      result = str
                     }
                 | tSTRING
                     {
@@ -1790,7 +1952,8 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          xstring: tXSTRING_BEG xstring_contents tSTRING_END
                     {
-                      result = new_xstring val[1]
+                      result = new_xstring val
+                      # TODO: dedent?!?! SERIOUSLY?!?
                     }
 
           regexp: tREGEXP_BEG regexp_contents tREGEXP_END
@@ -1800,7 +1963,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
            words: tWORDS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array)
+                      result = s(:array).line lexer.lineno
                     }
                 | tWORDS_BEG word_list tSTRING_END
                     {
@@ -1824,25 +1987,28 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          symbols: tSYMBOLS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array)
+                      result = s(:array).line lexer.lineno
                     }
-                | tSYMBOLS_BEG symbol_list tSTRING_END
+                | tSYMBOLS_BEG { result = lexer.lineno } symbol_list tSTRING_END
                     {
-                      result = val[1]
+                      _, line, list, _, = val
+                      list.line = line
+                      result = list
                     }
 
      symbol_list: none
                     {
-                      result = new_symbol_list
+                      result = new_symbol_list.line lexer.lineno
                     }
                 | symbol_list word tSPACE
                     {
-                      result = val[0].dup << new_symbol_list_entry(val)
+                      list, * = val
+                      result = list.dup << new_symbol_list_entry(val)
                     }
 
           qwords: tQWORDS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array)
+                      result = s(:array).line lexer.lineno
                     }
                 | tQWORDS_BEG qword_list tSTRING_END
                     {
@@ -1851,7 +2017,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
         qsymbols: tQSYMBOLS_BEG tSPACE tSTRING_END
                     {
-                      result = s(:array)
+                      result = s(:array).line lexer.lineno # FIX
                     }
                 | tQSYMBOLS_BEG qsym_list tSTRING_END
                     {
@@ -1878,11 +2044,12 @@ opt_block_args_tail: tCOMMA block_args_tail
 
  string_contents: none
                     {
-                      result = s(:str, "")
+                      result = s(:str, "").line lexer.lineno
                     }
                 | string_contents string_content
                     {
-                      result = literal_concat(val[0], val[1])
+                      v1, v2 = val
+                      result = literal_concat v1, v2
                     }
 
 xstring_contents: none
@@ -1891,7 +2058,8 @@ xstring_contents: none
                     }
                 | xstring_contents string_content
                     {
-                      result = literal_concat(val[0], val[1])
+                      v1, v2 = val
+                      result = literal_concat v1, v2
                     }
 
 regexp_contents: none
@@ -1900,7 +2068,8 @@ regexp_contents: none
                     }
                 | regexp_contents string_content
                     {
-                      result = literal_concat(val[0], val[1])
+                      v1, v2 = val
+                      result = literal_concat v1, v2
                     }
 
   string_content: tSTRING_CONTENT
@@ -1912,42 +2081,46 @@ regexp_contents: none
                       result = lexer.lex_strterm
 
                       lexer.lex_strterm = nil
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                     }
                     string_dvar
                     {
-                      lexer.lex_strterm = val[1]
-                      result = s(:evstr, val[2])
+                      _, strterm, str = val
+                      lexer.lex_strterm = strterm
+                      result = s(:evstr, str).line str.line
                     }
                 | tSTRING_DBEG
                     {
                       result = [lexer.lex_strterm,
                                 lexer.brace_nest,
                                 lexer.string_nest, # TODO: remove
-                                lexer.cond.store,
-                                lexer.cmdarg.store,
                                 lexer.lex_state,
+                                lexer.lineno,
                                ]
 
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
                       lexer.lex_strterm = nil
                       lexer.brace_nest  = 0
                       lexer.string_nest = 0
 
-                      lexer.lex_state   = :expr_beg
+                      lexer.lex_state   = EXPR_BEG
                     }
                     compstmt
                     tSTRING_DEND
                     {
                       _, memo, stmt, _ = val
 
-                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state = memo
+                      lex_strterm, brace_nest, string_nest, oldlex_state, line = memo
+                      # TODO: heredoc_indent
 
                       lexer.lex_strterm = lex_strterm
                       lexer.brace_nest  = brace_nest
                       lexer.string_nest = string_nest
 
-                      lexer.cond.restore oldcond
-                      lexer.cmdarg.restore oldcmdarg
+                      lexer.cmdarg.pop
+                      lexer.cond.pop
 
                       lexer.lex_state = oldlex_state
 
@@ -1957,24 +2130,24 @@ regexp_contents: none
                         when :str, :dstr, :evstr then
                           result = stmt
                         else
-                          result = s(:evstr, stmt)
+                          result = s(:evstr, stmt).line line
                         end
                       when nil then
-                        result = s(:evstr)
+                        result = s(:evstr).line line
                       else
                         debug20 25
                         raise "unknown string body: #{stmt.inspect}"
                       end
                     }
 
-     string_dvar: tGVAR { result = s(:gvar, val[0].to_sym) }
-                | tIVAR { result = s(:ivar, val[0].to_sym) }
-                | tCVAR { result = s(:cvar, val[0].to_sym) }
+     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 }
                 | backref
 
           symbol: tSYMBEG sym
                     {
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = val[1].to_sym
                     }
                 | tSYMBOL
@@ -1986,18 +2159,19 @@ regexp_contents: none
 
             dsym: tSYMBEG xstring_contents tSTRING_END
                     {
-                      lexer.lex_state = :expr_end
-                      result = val[1]
+                      _, result, _ = val
+
+                      lexer.lex_state = EXPR_END
 
-                      result ||= s(:str, "")
+                      result ||= s(:str, "").line lexer.lineno
 
                       case result.sexp_type
                       when :dstr then
                         result.sexp_type = :dsym
                       when :str then
-                        result = s(:lit, result.last.to_sym)
+                        result = s(:lit, result.last.to_sym).line result.line
                       when :evstr then
-                        result = s(:dsym, "", result)
+                        result = s(:dsym, "", result).line result.line
                       else
                         debug20 26, val, result
                       end
@@ -2020,19 +2194,20 @@ regexp_contents: none
                 | tCONSTANT
                 | tCVAR
 
-keyword_variable: kNIL      { result = s(:nil)   }
-                | kSELF     { result = s(:self)  }
-                | kTRUE     { result = s(:true)  }
-                | kFALSE    { result = s(:false) }
-                | k__FILE__ { result = s(:str, self.file) }
-                | k__LINE__ { result = s(:lit, lexer.lineno) }
+keyword_variable: kNIL      { result = s(:nil).line lexer.lineno }
+                | kSELF     { result = s(:self).line lexer.lineno }
+                | kTRUE     { result = s(:true).line lexer.lineno }
+                | kFALSE    { result = s(:false).line lexer.lineno }
+                | k__FILE__ { result = s(:str, self.file).line lexer.lineno }
+                | k__LINE__ { result = s(:lit, lexer.lineno).line lexer.lineno }
                 | k__ENCODING__
                     {
+                      l = lexer.lineno
                       result =
                         if defined? Encoding then
-                          s(:colon2, s(:const, :Encoding), :UTF_8)
+                          s(:colon2, s(:const, :Encoding).line(l), :UTF_8).line l
                         else
-                          s(:str, "Unsupported!")
+                          s(:str, "Unsupported!").line l
                         end
                     }
 
@@ -2057,12 +2232,12 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       debug20 29, val, result
                     }
 
-         backref: tNTH_REF  { result = s(:nth_ref,  val[0]) }
-                | tBACK_REF { result = s(:back_ref, val[0]) }
+         backref: tNTH_REF  { result = s(:nth_ref,  val[0]).line lexer.lineno }
+                | tBACK_REF { result = s(:back_ref, val[0]).line lexer.lineno }
 
       superclass: tLT
                     {
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                       lexer.command_start = true
                     }
                     expr_value term
@@ -2077,13 +2252,13 @@ keyword_variable: kNIL      { result = s(:nil)   }
        f_arglist: tLPAREN2 f_args rparen
                     {
                       result = val[1]
-                      self.lexer.lex_state = :expr_beg
+                      self.lexer.lex_state = EXPR_BEG
                       self.lexer.command_start = true
                     }
                 |   {
                       result = self.in_kwarg
                       self.in_kwarg = true
-                      # TODO: self.lexer.lex_state |= :expr_label
+                      self.lexer.lex_state |= EXPR_LABEL
                     }
                     f_args term
                     {
@@ -2091,7 +2266,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
                       self.in_kwarg = kwarg
                       result = args
-                      lexer.lex_state     = :expr_beg
+                      lexer.lex_state     = EXPR_BEG
                       lexer.command_start = true
                     }
 
@@ -2215,12 +2390,13 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
            f_arg: f_arg_item
                     {
-                      case val[0]
+                      arg, = val
+
+                      case arg
                       when Symbol then
-                        result = s(:args)
-                        result << val[0]
+                        result = s(:args, arg).line lexer.lineno
                       when Sexp then
-                        result = val[0]
+                        result = arg
                       else
                         debug20 32
                         raise "Unknown f_arg type: #{val.inspect}"
@@ -2233,7 +2409,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       if list.sexp_type == :args then
                         result = list
                       else
-                        result = s(:args, list)
+                        result = s(:args, list).line list.line
                       end
 
                       result << item
@@ -2243,38 +2419,42 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
             f_kw: f_label arg_value
                     {
-                      # TODO: call_args
-                      label, _ = val[0] # TODO: fix lineno?
+                      # TODO: new_kw_arg
+                      (label, line), arg = val
+
                       identifier = label.to_sym
                       self.env[identifier] = :lvar
 
-                      result = s(:array, s(:kwarg, identifier, val[1]))
+                      kwarg  = s(:kwarg, identifier, arg).line line
+                      result = s(:array, kwarg).line line
                     }
                 | f_label
                     {
-                      label, _ = val[0] # TODO: fix lineno?
-                      identifier = label.to_sym
-                      self.env[identifier] = :lvar
+                      (label, line), = val
 
-                      result = s(:array, s(:kwarg, identifier))
+                      id = label.to_sym
+                      self.env[id] = :lvar
+
+                      result = s(:array, s(:kwarg, id).line(line)).line line
                     }
 
       f_block_kw: f_label primary_value
                     {
-                      # TODO: call_args
-                      label, _ = val[0] # TODO: fix lineno?
-                      identifier = label.to_sym
-                      self.env[identifier] = :lvar
+                      # TODO: new_kw_arg
+                      (label, line), expr = val
+                      id = label.to_sym
+                      self.env[id] = :lvar
 
-                      result = s(:array, s(:kwarg, identifier, val[1]))
+                      result = s(:array, s(:kwarg, id, expr).line(line)).line line
                     }
                 | f_label
                     {
-                      label, _ = val[0] # TODO: fix lineno?
-                      identifier = label.to_sym
-                      self.env[identifier] = :lvar
+                      # TODO: new_kw_arg
+                      (label, line), = val
+                      id = label.to_sym
+                      self.env[id] = :lvar
 
-                      result = s(:array, s(:kwarg, identifier))
+                      result = s(:array, s(:kwarg, id).line(line)).line line
                     }
 
    f_block_kwarg: f_block_kw
@@ -2317,17 +2497,20 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
   f_block_optarg: f_block_opt
                     {
-                      result = s(:block, val[0])
+                      optblk, = val
+                      result = s(:block, optblk).line optblk.line
                     }
                 | f_block_optarg tCOMMA f_block_opt
                     {
-                      result = val[0]
-                      result << val[2]
+                      optarg, _, optblk = val
+                      result = optarg
+                      result << optblk
                     }
 
         f_optarg: f_opt
                     {
-                      result = s(:block, val[0])
+                      opt, = val
+                      result = s(:block, opt).line opt.line
                     }
                 | f_optarg tCOMMA f_opt
                     {
@@ -2372,7 +2555,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
        singleton: var_ref
                 | tLPAREN2
                     {
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                     }
                     expr rparen
                     {
@@ -2381,14 +2564,11 @@ keyword_variable: kNIL      { result = s(:nil)   }
                         result.sexp_type == :lit
                     }
 
-      assoc_list: none # [!nil]
+      assoc_list: none
                     {
-                      result = s(:array)
-                    }
-                | assocs trailer # [!nil]
-                    {
-                      result = val[0]
+                      result = s(:array).line lexer.lineno
                     }
+                | assocs trailer
 
           assocs: assoc
                 | assocs tCOMMA assoc
@@ -2402,22 +2582,27 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
            assoc: arg_value tASSOC arg_value
                     {
-                      result = s(:array, val[0], val[2])
+                      v1, _, v2 = val
+                      result = s(:array, v1, v2).line v1.line
                     }
                 | tLABEL arg_value
                     {
-                      (label, _), arg = val
-                      result = s(:array, s(:lit, label.to_sym), arg)
+                      (label, line), arg = val
+
+                      lit = s(:lit, label.to_sym).line line
+                      result = s(:array, lit, arg).line line
                     }
                 | tSTRING_BEG string_contents tLABEL_END arg_value
                     {
                       _, sym, _, value = val
                       sym.sexp_type = :dsym
-                      result = s(:array, sym, value)
+                      result = s(:array, sym, value).line sym.line
                     }
                 | tDSTAR arg_value
                     {
-                      result = s(:array, s(:kwsplat, val[1]))
+                      _, arg = val
+                      line = arg.line
+                      result = s(:array, s(:kwsplat, arg).line(line)).line line
                     }
 
        operation: tIDENTIFIER | tCONSTANT | tFID
@@ -2449,6 +2634,7 @@ end
 
 require "ruby_lexer"
 require "ruby_parser_extras"
+include RubyLexer::State::Values
 
 # :stopdoc: