brakeman 4.4.0 → 4.5.0

data/bundle/ruby/2.5.0/gems/{ruby_parser-3.12.0 → ruby_parser-3.13.0}/lib/ruby20_parser.y

@@ -85,14 +85,35 @@ rule
                       end
                       self.env.extend
                     }
-                  tLCURLY top_compstmt tRCURLY
+                    begin_block
                     {
-                      result = new_iter s(:preexe), nil, val[3]
+                      _, _, block = val
+                      result = block
+                    }
+
+     begin_block: tLCURLY top_compstmt tRCURLY
+                    {
+                      _, stmt, _ = val
+                      result = new_iter s(:preexe), 0, stmt
                     }
 
-        bodystmt: compstmt opt_rescue opt_else opt_ensure
+        bodystmt: compstmt opt_rescue k_else
                     {
-                      result = new_body val
+                      res = _values[-2]
+                      yyerror "else without rescue is useless" unless res
+                    }
+                    compstmt
+                    opt_ensure
+                    {
+                      body, resc, _, _, els, ens = val
+
+                      result = new_body [body, resc, els, ens]
+                    }
+                | compstmt opt_rescue opt_ensure
+                    {
+                      body, resc, ens = val
+
+                      result = new_body [body, resc, nil, ens]
                     }
 
         compstmt: stmts opt_terms
@@ -101,8 +122,8 @@ rule
                     }
 
            stmts: none
-                | stmt
-                | stmts terms stmt
+                | stmt_or_begin # TODO: newline_node ?
+                | stmts terms stmt_or_begin
                     {
                       result = self.block_append val[0], val[2]
                     }
@@ -112,6 +133,21 @@ rule
                       debug20 2, val, result
                     }
 
+   stmt_or_begin: stmt
+                | klBEGIN
+                    {
+                      if (self.in_def || self.in_single > 0) then
+                        debug20 1
+                        yyerror "BEGIN in method"
+                      end
+                      self.env.extend
+                    }
+                    begin_block
+                    {
+                      _, _, stmt = val
+                      result = stmt
+                    }
+
             stmt: kALIAS fitem
                     {
                       lexer.lex_state = :expr_fname
@@ -155,7 +191,8 @@ rule
                     }
                 | stmt kRESCUE_MOD stmt
                     {
-                      result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
+                      body, _, resbody = val
+                      result = new_rescue body, new_resbody(s(:array), resbody)
                     }
                 | klEND tLCURLY compstmt tRCURLY
                     {
@@ -170,15 +207,37 @@ rule
                     {
                       result = new_masgn val[0], val[2], :wrap
                     }
-                | var_lhs tOP_ASGN command_call
+                | lhs tEQL mrhs
+                    {
+                      result = new_assign val[0], s(:svalue, val[2])
+                    }
+                | mlhs tEQL arg_value
+                    {
+                      result = new_masgn val[0], val[2], :wrap
+                    }
+                | mlhs tEQL mrhs
+                    {
+                      result = new_masgn val[0], val[2]
+                    }
+                | expr
+
+    command_asgn: lhs tEQL command_rhs
+                    {
+                      result = new_assign val[0], val[2]
+                    }
+                # | lhs tEQL command_asgn
+                #     {
+                #       result = new_assign val[0], val[2]
+                #     }
+                | var_lhs tOP_ASGN command_rhs
                     {
                       result = new_op_asgn val
                     }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_call
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
-                | primary_value call_op tIDENTIFIER tOP_ASGN command_call
+                | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                       if val[1] == '&.'
@@ -186,7 +245,7 @@ rule
                       end
                       result.line = val[0].line
                     }
-                | primary_value call_op tCONSTANT tOP_ASGN command_call
+                | primary_value call_op tCONSTANT tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                       if val[1] == '&.'
@@ -194,42 +253,33 @@ rule
                       end
                       result.line = val[0].line
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
                       debug20 4, val, result
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
                       debug20 5, val, result
                     }
-                | backref tOP_ASGN command_call
+                | backref tOP_ASGN command_rhs
                     {
                       self.backref_assign_error val[0]
                     }
-                | lhs tEQL mrhs
-                    {
-                      result = new_assign val[0], s(:svalue, val[2])
-                    }
-                | mlhs tEQL arg_value
-                    {
-                      result = new_masgn val[0], val[2], :wrap
-                    }
-                | mlhs tEQL mrhs
-                    {
-                      result = new_masgn val[0], val[2]
-                    }
-                | expr
 
-    command_asgn: lhs tEQL command_call
+     command_rhs: command_call                =tOP_ASGN
                     {
-                      result = new_assign val[0], val[2]
+                      expr, = val
+                      result = value_expr expr
                     }
-                | lhs tEQL command_asgn
+                | command_call kRESCUE_MOD stmt
                     {
-                      result = new_assign val[0], val[2]
+                      expr, _, resbody = val
+                      expr = value_expr expr
+                      result = new_rescue(expr, new_resbody(s(:array), resbody))
                     }
+                | command_asgn
 
             expr: command_call
                 | expr kAND expr
@@ -255,30 +305,40 @@ rule
                       result = value_expr(val[0])
                     }
 
+   expr_value_do:   {
+                      lexer.cond.push true
+                    }
+                    expr_value do
+                    {
+                      lexer.cond.pop
+                    }
+                    {
+                      _, expr, _, _ = val
+                      result = expr
+                    }
+
     command_call: command
                 | block_command
 
    block_command: block_call
-                | block_call dot_or_colon operation2 command_args
+                | block_call call_op2 operation2 command_args
                     {
                       result = new_call val[0], val[2].to_sym, val[3]
                     }
 
  cmd_brace_block: tLBRACE_ARG
                     {
-                      self.env.extend(:dynamic)
+                      # self.env.extend(:dynamic)
                       result = self.lexer.lineno
                     }
-                    opt_block_param
-                    {
-                      result = nil # self.env.dynamic.keys
-                    }
-                    compstmt tRCURLY
+                    brace_body tRCURLY
                     {
-                      result = new_iter nil, val[2], val[4]
-                      result.line = val[1]
+                      _, line, body, _ = val
 
-                      self.env.unextend
+                      result = body
+                      result.line = line
+
+                      # self.env.unextend
                     }
 
            fcall: operation
@@ -336,7 +396,7 @@ rule
                     {
                       result = new_yield val[1]
                     }
-                | kRETURN call_args
+                | k_return call_args
                     {
                       line = val[0].last
                       result = s(:return, ret_args(val[1])).line(line)
@@ -560,8 +620,9 @@ rule
 
                 | reswords
                     {
+                      (sym, _line), = val
                       lexer.lex_state = :expr_end
-                      result = val[0]
+                      result = sym
                     }
 
             fsym: fname | symbol
@@ -603,51 +664,46 @@ rule
                 | kWHEN     | kYIELD    | kIF           | kUNLESS | kWHILE
                 | kUNTIL
 
-             arg: lhs tEQL arg
+             arg: lhs tEQL arg_rhs
                     {
                       result = new_assign val[0], val[2]
                     }
-                | lhs tEQL arg kRESCUE_MOD arg
-                    {
-                      result = new_assign val[0], s(:rescue, val[2], new_resbody(s(:array), val[4]))
-                    }
-                | var_lhs tOP_ASGN arg
+                | var_lhs tOP_ASGN arg_rhs
                     {
                       result = new_op_asgn val
                     }
-                | var_lhs tOP_ASGN arg kRESCUE_MOD arg
-                    {
-                      result = new_op_asgn val
-                      result = s(:rescue, result, new_resbody(s(:array), val[4]))
-                    }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
                     {
                       val[2].sexp_type = :arglist if val[2]
                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                     }
-                | primary_value call_op tIDENTIFIER tOP_ASGN arg
+                | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                     {
                       result = new_op_asgn2 val
                     }
-                | primary_value call_op tCONSTANT tOP_ASGN arg
+                | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
                     {
                       result = new_op_asgn2 val
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                     {
                       result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      yyerror "constant re-assignment"
+                      # TODO: assignment
+                      raise "not yet: %p" % [val]
                     }
-                | tCOLON3 tCONSTANT tOP_ASGN arg
+                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      yyerror "constant re-assignment"
+                      # TODO: assignment
+                      raise "not yet: %p" % [val]
                     }
-                | backref tOP_ASGN arg
+                | backref tOP_ASGN arg_rhs
                     {
-                      self.backref_assign_error val[0]
+                      # TODO: lhs = var_field val[0]
+                      asgn = new_op_asgn val
+                      result = self.backref_assign_error asgn
                     }
                 | arg tDOT2 arg
                     {
@@ -725,22 +781,7 @@ rule
                     {
                       result = new_call val[0], :"<=>", argl(val[2])
                     }
-                | arg tGT arg
-                    {
-                      result = new_call val[0], :">", argl(val[2])
-                    }
-                | arg tGEQ arg
-                    {
-                      result = new_call val[0], :">=", argl(val[2])
-                    }
-                | arg tLT arg
-                    {
-                      result = new_call val[0], :"<", argl(val[2])
-                    }
-                | arg tLEQ arg
-                    {
-                      result = new_call val[0], :"<=", argl(val[2])
-                    }
+                | rel_expr                      =tCMP
                 | arg tEQ arg
                     {
                       result = new_call val[0], :"==", argl(val[2])
@@ -799,6 +840,23 @@ rule
                     }
                 | primary
 
+           relop: tGT
+                | tLT
+                | tGEQ
+                | tLEQ
+
+        rel_expr: arg      relop arg                    =tGT
+                    {
+                      lhs, op, rhs = val
+                      result = new_call lhs, op.to_sym, argl(rhs)
+                    }
+                | rel_expr relop arg                    =tGT
+                    {
+                      lhs, op, rhs = val
+                      warn "comparison '%s' after comparison", op
+                      result = new_call lhs, op.to_sym, argl(rhs)
+                    }
+
        arg_value: arg
                     {
                       result = value_expr(val[0])
@@ -818,6 +876,15 @@ rule
                       result = args [array_to_hash(val[0])]
                     }
 
+         arg_rhs: arg                   =tOP_ASGN
+                | arg kRESCUE_MOD arg
+                    {
+                      body, _, resbody = val
+                      body    = value_expr body
+                      resbody = remove_begin resbody
+                      result  = new_rescue(body, new_resbody(s(:array), resbody))
+                    }
+
       paren_args: tLPAREN2 opt_call_args rparen
                     {
                       result = val[1]
@@ -873,12 +940,11 @@ rule
                     }
 
     command_args:   {
-                      result = lexer.cmdarg.stack.dup # TODO: smell?
-                      lexer.cmdarg.push true
+                      result = lexer.cmdarg.store true
                     }
                       call_args
                     {
-                      lexer.cmdarg.stack.replace val[0]
+                      lexer.cmdarg.restore val[0]
                       result = val[1]
                     }
 
@@ -937,12 +1003,16 @@ rule
                     {
                       result = new_call nil, val[0].to_sym
                     }
-                | kBEGIN
+                | k_begin
                     {
                       result = self.lexer.lineno
+                      # TODO:
+                      # $<val>1 = cmdarg_stack;
+                      # CMDARG_SET(0);
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
+                      # TODO: CMDARG_SET($<val>1);
                       unless val[2] then
                         result = s(:nil)
                       else
@@ -953,22 +1023,25 @@ rule
                     }
                 | tLPAREN_ARG rparen
                     {
+                      # TODO: lex_state = :expr_endarg in between
                       debug20 13, val, result
                     }
                 | tLPAREN_ARG
                     {
-                      result = self.lexer.cmdarg.stack.dup
-                      lexer.cmdarg.stack.replace [false] # TODO add api for these
+                      result = lexer.cmdarg.store false
+                      # result = self.lexer.cmdarg.stack.dup
+                      # lexer.cmdarg.stack.replace [false] # TODO add api for these
                     }
-                    expr
+                    stmt
                     {
                       lexer.lex_state = :expr_endarg
                     }
                     rparen
                     {
+                      _, cmdarg, stmt, _, _, = val
                       warning "(...) interpreted as grouped expression"
-                      lexer.cmdarg.stack.replace val[1]
-                      result = val[2]
+                      lexer.cmdarg.restore cmdarg
+                      result = stmt
                     }
                 | tLPAREN compstmt tRPAREN
                     {
@@ -996,7 +1069,7 @@ rule
                     {
                       result = new_hash val
                     }
-                | kRETURN
+                | k_return
                     {
                       result = s(:return)
                     }
@@ -1044,61 +1117,42 @@ rule
                     {
                       result = val[1] # TODO: fix lineno
                     }
-                | kIF expr_value then compstmt if_tail kEND
-                    {
-                      result = new_if val[1], val[3], val[4]
-                    }
-                | kUNLESS expr_value then compstmt opt_else kEND
-                    {
-                      result = new_if val[1], val[4], val[3]
-                    }
-                | kWHILE
-                    {
-                      lexer.cond.push true
-                    }
-                    expr_value do
-                    {
-                      lexer.cond.pop
-                    }
-                    compstmt kEND
+                | k_if expr_value then compstmt if_tail k_end
                     {
-                      result = new_while val[5], val[2], true
+                      _, c, _, t, f, _ = val
+                      result = new_if c, t, f
                     }
-                | kUNTIL
+                | k_unless expr_value then compstmt opt_else k_end
                     {
-                      lexer.cond.push true
+                      _, c, _, t, f, _ = val
+                      result = new_if c, f, t
                     }
-                    expr_value do
+                | k_while expr_value_do compstmt k_end
                     {
-                      lexer.cond.pop
+                      _, cond, body, _ = val
+                      result = new_while body, cond, true
                     }
-                    compstmt kEND
+                | k_until expr_value_do compstmt k_end
                     {
-                      result = new_until val[5], val[2], true
+                      _, cond, body, _ = val
+                      result = new_until body, cond, true
                     }
-                | kCASE expr_value opt_terms case_body kEND
+                | k_case expr_value opt_terms case_body k_end
                     {
                       (_, line), expr, _, body, _ = val
                       result = new_case expr, body, line
                     }
-                | kCASE            opt_terms case_body kEND
+                | k_case            opt_terms case_body k_end
                     {
                       (_, line), _, body, _ = val
                       result = new_case nil, body, line
                     }
-                | kFOR for_var kIN
+                | k_for for_var kIN expr_value_do compstmt k_end
                     {
-                      lexer.cond.push true
+                      _, var, _, iter, body, _ = val
+                      result = new_for iter, var, body
                     }
-                    expr_value do
-                    {
-                      lexer.cond.pop
-                    }
-                    compstmt kEND
-                    {
-                      result = new_for val[4], val[1], val[7]
-                    }
-                | kCLASS
+                | k_class
                     {
                       result = self.lexer.lineno
                     }
@@ -1110,13 +1164,13 @@ rule
                       end
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_class val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kCLASS tLSHFT
+                | k_class tLSHFT
                     {
                       result = self.lexer.lineno
                     }
@@ -1131,13 +1185,13 @@ rule
                       self.in_single = 0
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_sclass val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kMODULE
+                | k_module
                     {
                       result = self.lexer.lineno
                     }
@@ -1149,13 +1203,13 @@ rule
 
                       self.env.extend
                     }
-                    bodystmt kEND
+                    bodystmt k_end
                     {
                       result = new_module val
                       self.env.unextend
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kDEF fname
+                | k_def fname
                     {
                       result = [self.in_def, self.lexer.cmdarg.stack.dup]
 
@@ -1166,7 +1220,7 @@ rule
                       # TODO: port local_push_gen and local_pop_gen
                       lexer.cmdarg.stack.replace [false]
                     }
-                    f_arglist bodystmt kEND
+                    f_arglist bodystmt k_end
                     {
                       in_def, cmdarg = val[2]
 
@@ -1177,7 +1231,7 @@ rule
                       self.in_def = in_def
                       self.lexer.comments # we don't care about comments in the body
                     }
-                | kDEF singleton dot_or_colon
+                | k_def singleton dot_or_colon
                     {
                       self.comments.push self.lexer.comments
                       lexer.lex_state = :expr_fname
@@ -1190,7 +1244,7 @@ rule
                       result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
                       lexer.cmdarg.stack.replace [false]
                     }
-                    f_arglist bodystmt kEND
+                    f_arglist bodystmt k_end
                     {
                       line, cmdarg = val[5]
                       result = new_defs val
@@ -1235,7 +1289,15 @@ rule
          k_class: kCLASS
         k_module: kMODULE
            k_def: kDEF
+            k_do: kDO
+      k_do_block: kDO_BLOCK
+        k_rescue: kRESCUE
+        k_ensure: kENSURE
+          k_when: kWHEN
+          k_else: kELSE
+         k_elsif: kELSIF
            k_end: kEND
+        k_return: kRETURN
 
             then: term
                 | kTHEN
@@ -1245,7 +1307,7 @@ rule
                 | kDO_COND
 
          if_tail: opt_else
-                | kELSIF expr_value then compstmt if_tail
+                | k_elsif expr_value then compstmt if_tail
                     {
                       result = s(:if, val[1], val[3], val[4])
                     }
@@ -1416,18 +1478,22 @@ opt_block_args_tail: tCOMMA block_args_tail
 
  opt_block_param: none { result = 0 }
                 | block_param_def
+                    {
+                      self.lexer.command_start = true
+                    }
 
  block_param_def: tPIPE opt_bv_decl tPIPE
                     {
+                      # TODO: current_arg = 0
                       result = args val
                     }
                 | tOROP
                     {
-                      self.lexer.command_start = true
                       result = s(:args)
                     }
                 | tPIPE block_param opt_bv_decl tPIPE
                     {
+                      # TODO: current_arg = 0
                       result = args val
                     }
 
@@ -1460,13 +1526,21 @@ opt_block_args_tail: tCOMMA block_args_tail
                       lexer.paren_nest += 1
                       lexer.lpar_beg = lexer.paren_nest
                     }
-                    f_larglist lambda_body
+                    f_larglist
                     {
-                      lpar, args, body = val
+                      result = [lexer.cmdarg.store(false), self.lexer.lineno]
+                    }
+                    lambda_body
+                    {
+                      lpar, args, (cmdarg, lineno), body = val
                       lexer.lpar_beg = lpar
 
+                      lexer.cmdarg.restore cmdarg
+                      lexer.cmdarg.lexpop
+
                       call = new_call nil, :lambda
                       result = new_iter call, args, body
+                      result.line = lineno
                       self.env.unextend
                     }
 
@@ -1484,28 +1558,15 @@ opt_block_args_tail: tCOMMA block_args_tail
                     {
                       result = val[1]
                     }
-                | kDO_LAMBDA compstmt kEND
+                | kDO_LAMBDA bodystmt kEND
                     {
                       result = val[1]
                     }
 
-        do_block: kDO_BLOCK
+        do_block: k_do_block do_body kEND
                     {
-                      self.env.extend :dynamic
-                      result = self.lexer.lineno
-                    }
-                    opt_block_param
-                    {
-                      result = nil # self.env.dynamic.keys
-                    }
-                    compstmt kEND
-                    {
-                      args   = val[2]
-                      body   = val[4]
-                      result = new_iter nil, args, body
-                      result.line = val[1]
-
-                      self.env.unextend
+                      # TODO: maybe fix lineno to kDO's lineno?
+                      result = val[1]
                     }
 
       block_call: command do_block
@@ -1522,11 +1583,11 @@ opt_block_args_tail: tCOMMA block_args_tail
                       result = val[1]
                       result.insert 1, val[0]
                     }
-                | block_call dot_or_colon operation2 opt_paren_args
+                | block_call call_op2 operation2 opt_paren_args
                     {
                       result = new_call val[0], val[2].to_sym, val[3]
                     }
-                | block_call dot_or_colon operation2 opt_paren_args brace_block
+                | block_call call_op2 operation2 opt_paren_args brace_block
                     {
                       iter1, _, name, args, iter2 = val
 
@@ -1535,7 +1596,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
                       result = iter2
                     }
-                | block_call dot_or_colon operation2 command_args do_block
+                | block_call call_op2 operation2 command_args do_block
                     {
                       iter1, _, name, args, iter2 = val
 
@@ -1592,39 +1653,55 @@ opt_block_args_tail: tCOMMA block_args_tail
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                    opt_block_param
-                    {
-                      result = nil # self.env.dynamic.keys
-                    }
-                    compstmt tRCURLY
+                    brace_body tRCURLY
                     {
-                      _, line, args, _, body, _ = val
+                      _, line, body, _ = val
 
-                      result = new_iter nil, args, body
+                      result = body
                       result.line = line
 
                       self.env.unextend
                     }
-                | kDO
+                | k_do
                     {
                       self.env.extend :dynamic
                       result = self.lexer.lineno
                     }
-                    opt_block_param
+                    do_body kEND
                     {
-                      result = nil # self.env.dynamic.keys
+                      _, line, body, _ = val
+
+                      result = body
+                      result.line = line
+
+                      self.env.unextend
                     }
-                    compstmt kEND
+
+      brace_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
+                    { result = lexer.cmdarg.store(false) }
+                    opt_block_param compstmt
                     {
-                      _, line, args, _, body, _ = val
+                      line, cmdarg, param, cmpstmt = val
 
-                      result = new_iter nil, args, body
-                      result.line = line
+                      result = new_brace_body param, cmpstmt, line
+                      self.env.unextend
+                      lexer.cmdarg.restore cmdarg
+                      lexer.cmdarg.pop # because of: cmdarg_stack >> 1 ?
+                    }
+
+         do_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
+                    { result = lexer.cmdarg.store(false) }
+                    opt_block_param
+                    compstmt
+                    {
+                      line, cmdarg, param, cmpstmt = val
 
+                      result = new_do_body param, cmpstmt, line
                       self.env.unextend
+                      lexer.cmdarg.restore cmdarg
                     }
 
-       case_body: kWHEN
+       case_body: k_when
                     {
                       result = self.lexer.lineno
                     }
@@ -1637,7 +1714,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
            cases: opt_else | case_body
 
-      opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
+      opt_rescue: k_rescue exc_list exc_var then compstmt opt_rescue
                     {
                       (_, line), klasses, var, _, body, rest = val
 
@@ -1666,7 +1743,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                 | none
 
-      opt_ensure: kENSURE compstmt
+      opt_ensure: k_ensure compstmt
                     {
                       _, body = val
 
@@ -1833,7 +1910,7 @@ regexp_contents: none
                       result = lexer.lex_strterm
 
                       lexer.lex_strterm = nil
-                      lexer.lex_state = :expr_beg # TODO: expr_value ?
+                      lexer.lex_state = :expr_beg
                     }
                     string_dvar
                     {
@@ -1854,11 +1931,11 @@ regexp_contents: none
                       lexer.brace_nest  = 0
                       lexer.string_nest = 0
 
-                      lexer.lex_state   = :expr_value
+                      lexer.lex_state   = :expr_beg
                     }
-                    compstmt tRCURLY
+                    compstmt
+                    tSTRING_DEND
                     {
-                      # TODO: tRCURLY -> tSTRING_DEND
                       _, memo, stmt, _ = val
 
                       lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state = memo
@@ -1981,23 +2058,18 @@ keyword_variable: kNIL      { result = s(:nil)   }
          backref: tNTH_REF  { result = s(:nth_ref,  val[0]) }
                 | tBACK_REF { result = s(:back_ref, val[0]) }
 
-      superclass: term
-                    {
-                      result = nil
-                    }
-                | tLT
+      superclass: tLT
                     {
                       lexer.lex_state = :expr_beg
+                      lexer.command_start = true
                     }
                     expr_value term
                     {
                       result = val[2]
                     }
-                | error term
+                | none
                     {
-                      yyerrok
                       result = nil
-                      debug20 30, val, result
                     }
 
        f_arglist: tLPAREN2 f_args rparen
@@ -2005,16 +2077,20 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       result = val[1]
                       self.lexer.lex_state = :expr_beg
                       self.lexer.command_start = true
-                      # TODO:
-                      # $<num>$ = parser->parser_in_kwarg;
-                      # parser->parser_in_kwarg = 1;
                     }
-                | f_args term
+                |   {
+                      result = self.in_kwarg
+                      self.in_kwarg = true
+                      # TODO: self.lexer.lex_state |= :expr_label
+                    }
+                    f_args term
                     {
-                      # TODO: parser->parser_in_kwarg = $<num>1;
-                      result = val[0]
-                      self.lexer.lex_state = :expr_beg
-                      self.lexer.command_start = true
+                      kwarg, args, _ = val
+
+                      self.in_kwarg = kwarg
+                      result = args
+                      lexer.lex_state     = :expr_beg
+                      lexer.command_start = true
                     }
 
        args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
@@ -2197,7 +2273,9 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
         f_kwrest: kwrest_mark tIDENTIFIER
                     {
-                      result = :"**#{val[1]}"
+                      name = val[1].to_sym
+                      self.assignable name
+                      result = :"**#{name}"
                     }
                 | kwrest_mark
                     {
@@ -2304,9 +2382,10 @@ keyword_variable: kNIL      { result = s(:nil)   }
                     {
                       result = s(:array, val[0], val[2])
                     }
-                | tLABEL opt_nl arg_value
+                | tLABEL arg_value
                     {
-                      result = s(:array, s(:lit, val[0][0].to_sym), val.last)
+                      (label, _), arg = val
+                      result = s(:array, s(:lit, label.to_sym), arg)
                     }
                 | tDSTAR arg_value
                     {
@@ -2318,6 +2397,10 @@ keyword_variable: kNIL      { result = s(:nil)   }
       operation3: tIDENTIFIER | tFID | op
     dot_or_colon: tDOT | tCOLON2
          call_op: tDOT
+
+        call_op2: call_op
+                | tCOLON2
+
        opt_terms:  | terms
           opt_nl:  | tNL
           rparen: opt_nl tRPAREN