ruby_parser 3.13.1 → 3.14.0

data/lib/ruby23_parser.y

@@ -23,30 +23,30 @@ 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
 
@@ -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
                     }
                     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
@@ -277,19 +279,26 @@ rule
             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
 
@@ -316,7 +325,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
@@ -336,26 +346,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
                     {
@@ -387,7 +403,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
                     {
@@ -396,8 +414,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
                     {
@@ -414,56 +432,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
@@ -474,7 +515,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
                     {
@@ -483,7 +525,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
                     {
@@ -508,7 +551,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
                     {
@@ -521,7 +565,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
                     {
@@ -530,7 +577,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
                     {
@@ -539,24 +589,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?
                     {
@@ -564,21 +621,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
                     {
@@ -593,7 +656,8 @@ rule
 
            cpath: tCOLON3 cname
                     {
-                      result = s(:colon3, val[1].to_sym)
+                      _, name = val
+                      result = s(:colon3, name.to_sym).line lexer.lineno
                     }
                 | cname
                     {
@@ -601,7 +665,10 @@ 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
@@ -622,7 +689,8 @@ rule
 
            fitem: fsym
                     {
-                      result = s(:lit, val[0].to_sym)
+                      id, = val
+                      result = s(:lit, id.to_sym).line lexer.lineno
                     }
                 | dsym
 
@@ -645,6 +713,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
@@ -667,8 +736,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
                     {
@@ -680,7 +748,9 @@ 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
                     {
@@ -710,18 +780,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
@@ -750,7 +820,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
                     {
@@ -791,15 +863,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
                     {
@@ -827,11 +903,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
 
@@ -874,28 +952,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
@@ -945,7 +1020,8 @@ rule
 
        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
@@ -956,19 +1032,24 @@ rule
 
             args: arg_value
                     {
-                      result = s(:array, val[0])
+                      arg, = val
+
+                      result = s(:array, arg).line arg.line
                     }
                 | 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
+                | args tCOMMA tSTAR { result = lexer.lineno } arg_value
                     {
-                      result = self.list_append val[0], s(:splat, val[3])
+                      args, _, _, line, id = val
+                      result = self.list_append args, s(:splat, id).line(line)
                     }
 
         mrhs_arg: mrhs
@@ -986,11 +1067,15 @@ rule
                     }
                 | args tCOMMA tSTAR arg_value
                     {
-                      result = self.arg_concat val[0], val[3]
+                      # FIX: bad shift/reduce conflict with rhs' comma star prod
+                      # 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
@@ -1005,7 +1090,8 @@ rule
                 | backref
                 | tFID
                     {
-                      result = new_call nil, val[0].to_sym
+                      msg, = val
+                      result = new_call nil, msg.to_sym
                     }
                 | k_begin
                     {
@@ -1025,16 +1111,19 @@ rule
 
                       result.line = val[1]
                     }
-                | tLPAREN_ARG rparen
+                | tLPAREN_ARG
                     {
-                      # TODO: lex_state = EXPR_ENDARG in between
-                      debug20 13, val, result
+                      lexer.lex_state = EXPR_ENDARG
+                      result = lexer.lineno
+                    }
+                    rparen
+                    {
+                      _, line, _ = val
+                      result = s(:begin).line line
                     }
                 | tLPAREN_ARG
                     {
                       result = lexer.cmdarg.store false
-                      # result = self.lexer.cmdarg.stack.dup
-                      # lexer.cmdarg.stack.replace [false] # TODO add api for these
                     }
                     stmt
                     {
@@ -1049,21 +1138,29 @@ rule
                     }
                 | 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
                     {
@@ -1075,7 +1172,8 @@ rule
                     }
                 | k_return
                     {
-                      result = s(:return)
+                      (_, line), = val
+                      result = s(:return).line line
                     }
                 | kYIELD tLPAREN2 call_args rparen
                     {
@@ -1091,11 +1189,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
                     {
@@ -1103,11 +1204,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
@@ -1224,7 +1325,7 @@ rule
                       # TODO: port local_push_gen and local_pop_gen
                       lexer.cmdarg.stack.replace [false]
                     }
-                    f_arglist bodystmt k_end
+                    f_arglist bodystmt { result = lexer.lineno } k_end
                     {
                       in_def, cmdarg = val[2]
 
@@ -1250,9 +1351,8 @@ rule
                     }
                     f_arglist bodystmt k_end
                     {
-                      line, cmdarg = val[5]
+                      _, cmdarg = val[5]
                       result = new_defs val
-                      result[3].line line
 
                       lexer.cmdarg.stack.replace cmdarg
 
@@ -1262,19 +1362,23 @@ rule
                     }
                 | 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
@@ -1313,7 +1417,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
@@ -1336,7 +1442,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
                     {
@@ -1410,7 +1518,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
@@ -1441,7 +1551,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
                     {
@@ -1493,7 +1603,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
                     {
@@ -1518,33 +1628,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]
+                      result = lexer.cmdarg.store(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
 
-                      call = new_call nil, :lambda
+                      call = s(:lambda).line line
                       result = new_iter call, args, body
-                      result.line = lineno
+                      result.line = line
                       self.env.unextend
                     }
 
@@ -1569,8 +1679,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
@@ -1584,8 +1694,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
                     {
@@ -1616,8 +1728,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
                     {
@@ -1645,7 +1759,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
                     {
@@ -1723,7 +1837,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)
@@ -1736,7 +1850,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
@@ -1749,26 +1864,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
@@ -1783,7 +1903,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
                     {
@@ -1793,6 +1917,7 @@ opt_block_args_tail: tCOMMA block_args_tail
          xstring: tXSTRING_BEG xstring_contents tSTRING_END
                     {
                       result = new_xstring val[1]
+                      # TODO: dedent?!?! SERIOUSLY?!?
                     }
 
           regexp: tREGEXP_BEG regexp_contents tREGEXP_END
@@ -1802,7 +1927,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
                     {
@@ -1826,25 +1951,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
                     {
@@ -1853,7 +1981,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
                     {
@@ -1880,11 +2008,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
@@ -1893,7 +2022,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
@@ -1902,7 +2032,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
@@ -1918,8 +2049,9 @@ regexp_contents: none
                     }
                     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
                     {
@@ -1929,6 +2061,7 @@ regexp_contents: none
                                 lexer.cond.store,
                                 lexer.cmdarg.store,
                                 lexer.lex_state,
+                                lexer.lineno,
                                ]
 
                       lexer.lex_strterm = nil
@@ -1942,7 +2075,7 @@ regexp_contents: none
                     {
                       _, memo, stmt, _ = val
 
-                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state = memo
+                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state, line = memo
 
                       lexer.lex_strterm = lex_strterm
                       lexer.brace_nest  = brace_nest
@@ -1959,19 +2092,19 @@ 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
@@ -1988,18 +2121,19 @@ regexp_contents: none
 
             dsym: tSYMBEG xstring_contents tSTRING_END
                     {
+                      _, result, _ = val
+
                       lexer.lex_state = EXPR_END
-                      result = val[1]
 
-                      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
@@ -2022,19 +2156,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
                     }
 
@@ -2059,8 +2194,8 @@ 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
                     {
@@ -2217,12 +2352,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}"
@@ -2235,7 +2371,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
@@ -2245,38 +2381,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
@@ -2319,17 +2459,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
                     {
@@ -2383,14 +2526,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
@@ -2404,22 +2544,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