parser 2.6.5.0 → 2.7.0.4

data/lib/parser/{lexer/max_numparam_stack.rb → max_numparam_stack.rb}

@@ -2,17 +2,23 @@
 
 module Parser
 
-  class Lexer::MaxNumparamStack
+  class MaxNumparamStack
+    attr_reader :stack
+
     def initialize
       @stack = []
     end
 
-    def cant_have_numparams!
+    def has_ordinary_params!
       set(-1)
     end
 
-    def can_have_numparams?
-      top >= 0
+    def has_ordinary_params?
+      top < 0
+    end
+
+    def has_numparams?
+      top > 0
     end
 
     def register(numparam)

data/lib/parser/messages.rb

@@ -31,42 +31,48 @@ module Parser
     :heredoc_id_has_newline   => 'here document identifier across newlines, never match',
     :heredoc_id_ends_with_nl  => 'here document identifier ends with a newline',
     :unterminated_heredoc_id  => 'unterminated heredoc id',
-    :leading_zero_in_numparam => 'leading zero is not allowed as a numbered parameter',
-    :numparam_outside_block   => 'numbered parameter outside block',
-    :too_large_numparam       => 'too large numbered parameter',
-    :ordinary_param_defined   => 'ordinary parameter is defined',
 
     # Lexer warnings
     :invalid_escape_use      => 'invalid character syntax; use ?%{escape}',
     :ambiguous_literal       => 'ambiguous first argument; put parentheses or a space even after the operator',
     :ambiguous_prefix        => "`%{prefix}' interpreted as argument prefix",
+    :triple_dot_at_eol       => '... at EOL, should be parenthesized',
 
     # Parser errors
-    :nth_ref_alias           => 'cannot define an alias for a back-reference variable',
-    :begin_in_method         => 'BEGIN in method',
-    :backref_assignment      => 'cannot assign to a back-reference variable',
-    :invalid_assignment      => 'cannot assign to a keyword',
-    :module_name_const       => 'class or module name must be a constant literal',
-    :unexpected_token        => 'unexpected token %{token}',
-    :argument_const          => 'formal argument cannot be a constant',
-    :argument_ivar           => 'formal argument cannot be an instance variable',
-    :argument_gvar           => 'formal argument cannot be a global variable',
-    :argument_cvar           => 'formal argument cannot be a class variable',
-    :duplicate_argument      => 'duplicate argument name',
-    :empty_symbol            => 'empty symbol literal',
-    :odd_hash                => 'odd number of entries for a hash',
-    :singleton_literal       => 'cannot define a singleton method for a literal',
-    :dynamic_const           => 'dynamic constant assignment',
-    :const_reassignment      => 'constant re-assignment',
-    :module_in_def           => 'module definition in method body',
-    :class_in_def            => 'class definition in method body',
-    :unexpected_percent_str  => '%{type}: unknown type of percent-literal',
-    :block_and_blockarg      => 'both block argument and literal block are passed',
-    :masgn_as_condition      => 'multiple assignment in conditional context',
-    :block_given_to_yield    => 'block given to yield',
-    :invalid_regexp          => '%{message}',
-    :invalid_return          => 'Invalid return in class/module body',
-    :csend_in_lhs_of_masgn   => '&. inside multiple assignment destination',
+    :nth_ref_alias                => 'cannot define an alias for a back-reference variable',
+    :begin_in_method              => 'BEGIN in method',
+    :backref_assignment           => 'cannot assign to a back-reference variable',
+    :invalid_assignment           => 'cannot assign to a keyword',
+    :module_name_const            => 'class or module name must be a constant literal',
+    :unexpected_token             => 'unexpected token %{token}',
+    :argument_const               => 'formal argument cannot be a constant',
+    :argument_ivar                => 'formal argument cannot be an instance variable',
+    :argument_gvar                => 'formal argument cannot be a global variable',
+    :argument_cvar                => 'formal argument cannot be a class variable',
+    :duplicate_argument           => 'duplicate argument name',
+    :empty_symbol                 => 'empty symbol literal',
+    :odd_hash                     => 'odd number of entries for a hash',
+    :singleton_literal            => 'cannot define a singleton method for a literal',
+    :dynamic_const                => 'dynamic constant assignment',
+    :const_reassignment           => 'constant re-assignment',
+    :module_in_def                => 'module definition in method body',
+    :class_in_def                 => 'class definition in method body',
+    :unexpected_percent_str       => '%{type}: unknown type of percent-literal',
+    :block_and_blockarg           => 'both block argument and literal block are passed',
+    :masgn_as_condition           => 'multiple assignment in conditional context',
+    :block_given_to_yield         => 'block given to yield',
+    :invalid_regexp               => '%{message}',
+    :invalid_return               => 'Invalid return in class/module body',
+    :csend_in_lhs_of_masgn        => '&. inside multiple assignment destination',
+    :cant_assign_to_numparam      => 'cannot assign to numbered parameter %{name}',
+    :ordinary_param_defined       => 'ordinary parameter is defined',
+    :numparam_used_in_outer_scope => 'numbered parameter is already used in an outer scope',
+    :circular_argument_reference  => 'circular argument reference %{var_name}',
+    :pm_interp_in_var_name        => 'symbol literal with interpolation is not allowed',
+    :lvar_name                    => "`%{name}' is not allowed as a local variable name",
+    :undefined_lvar               => "no such local variable: `%{name}'",
+    :duplicate_variable_name      => 'duplicate variable name %{name}',
+    :duplicate_pattern_key        => 'duplicate hash pattern key %{name}',
 
     # Parser warnings
     :useless_else            => 'else without rescue is useless',

data/lib/parser/meta.rb

@@ -24,9 +24,14 @@ module Parser
         kwbegin begin retry preexe postexe iflipflop eflipflop
         shadowarg complex rational __FILE__ __LINE__ __ENCODING__
         ident root lambda indexasgn index procarg0
-        meth_ref restarg_expr blockarg_expr
+        restarg_expr blockarg_expr
         objc_kwarg objc_restarg objc_varargs
-        numargs numblock numparam
+        numargs numblock forward_args forwarded_args
+        case_match in_match in_pattern
+        match_var pin match_alt match_as match_rest
+        array_pattern match_with_trailing_comma array_pattern_with_tail
+        hash_pattern const_pattern if_guard unless_guard match_nil_pattern
+        empty_else
       ).map(&:to_sym).to_set.freeze
 
   end # Meta

data/lib/parser/ruby27.y

@@ -17,7 +17,7 @@ token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
       tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DBEG
       tSTRING_DVAR tSTRING_END tSTRING_DEND tSTRING tSYMBOL
       tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG tCHARACTER
-      tRATIONAL tIMAGINARY tLABEL_END tANDDOT tMETHREF tBDOT2 tBDOT3 tNUMPARAM
+      tRATIONAL tIMAGINARY tLABEL_END tANDDOT tBDOT2 tBDOT3
 
 prechigh
   right    tBANG tTILDE tUPLUS
@@ -39,7 +39,7 @@ prechigh
   nonassoc kDEFINED
   right    kNOT
   left     kOR kAND
-  nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
+  nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD kIN
   nonassoc tLBRACE_ARG
   nonassoc tLOWEST
 preclow
@@ -283,7 +283,21 @@ rule
                     {
                       result = @builder.not_op(val[0], nil, val[1], nil)
                     }
-                | arg
+                | arg kIN
+                    {
+                      @lexer.state = :expr_beg
+                      @lexer.command_start = false
+                      pattern_variables.push
+
+                      result = @lexer.in_kwarg
+                      @lexer.in_kwarg = true
+                    }
+                  p_expr
+                    {
+                      @lexer.in_kwarg = val[2]
+                      result = @builder.in_match(val[0], val[1], val[3])
+                    }
+                | arg =tLBRACE_ARG
 
       expr_value: expr
 
@@ -843,6 +857,14 @@ rule
                     {
                       result = val
                     }
+                | tLPAREN2 args_forward rparen
+                    {
+                      unless @static_env.declared_forward_args?
+                        diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[1]
+                      end
+
+                      result = [val[0], [@builder.forwarded_args(val[1])], val[2]]
+                    }
 
   opt_paren_args: # nothing
                     {
@@ -1133,6 +1155,14 @@ rule
                                              when_bodies, else_t, else_body,
                                              val[3])
                     }
+                | kCASE expr_value opt_terms p_case_body kEND
+                    {
+                      *in_bodies, (else_t, else_body) = *val[3]
+
+                      result = @builder.case_match(val[0], val[1],
+                                             in_bodies, else_t, else_body,
+                                             val[4])
+                    }
                 | kFOR for_var kIN expr_value_do compstmt kEND
                     {
                       result = @builder.for(val[0], val[1], val[2], *val[3], val[4], val[5])
@@ -1200,6 +1230,7 @@ rule
                       @lexer.cmdarg.push(false)
                       @lexer.cond.push(false)
                       @context.push(:def)
+                      @current_arg_stack.push(nil)
                     }
                     f_arglist bodystmt kEND
                     {
@@ -1210,6 +1241,7 @@ rule
                       @lexer.cond.pop
                       @static_env.unextend
                       @context.pop
+                      @current_arg_stack.pop
                     }
                 | kDEF singleton dot_or_colon
                     {
@@ -1221,6 +1253,7 @@ rule
                       @lexer.cmdarg.push(false)
                       @lexer.cond.push(false)
                       @context.push(:defs)
+                      @current_arg_stack.push(nil)
                     }
                     f_arglist bodystmt kEND
                     {
@@ -1231,6 +1264,7 @@ rule
                       @lexer.cond.pop
                       @static_env.unextend
                       @context.pop
+                      @current_arg_stack.pop
                     }
                 | kBREAK
                     {
@@ -1248,10 +1282,6 @@ rule
                     {
                       result = @builder.keyword_cmd(:retry, val[0])
                     }
-                | primary_value tMETHREF operation2
-                    {
-                      result = @builder.method_ref(val[0], val[1], val[2])
-                    }
 
    primary_value: primary
 
@@ -1469,17 +1499,14 @@ opt_block_args_tail:
 
  block_param_def: tPIPE opt_bv_decl tPIPE
                     {
-                      @lexer.max_numparam_stack.cant_have_numparams!
+                      @max_numparam_stack.has_ordinary_params!
+                      @current_arg_stack.set(nil)
                       result = @builder.args(val[0], val[1], val[2])
                     }
-                | tOROP
-                    {
-                      @lexer.max_numparam_stack.cant_have_numparams!
-                      result = @builder.args(val[0], [], val[0])
-                    }
                 | tPIPE block_param opt_bv_decl tPIPE
                     {
-                      @lexer.max_numparam_stack.cant_have_numparams!
+                      @max_numparam_stack.has_ordinary_params!
+                      @current_arg_stack.set(nil)
                       result = @builder.args(val[0], val[1].concat(val[2]), val[3])
                     }
 
@@ -1510,7 +1537,7 @@ opt_block_args_tail:
 
           lambda:   {
                       @static_env.extend_dynamic
-                      @lexer.max_numparam_stack.push
+                      @max_numparam_stack.push
                       @context.push(:lambda)
                     }
                   f_larglist
@@ -1520,23 +1547,23 @@ opt_block_args_tail:
                     }
                   lambda_body
                     {
-                      args = @lexer.max_numparam > 0 ? @builder.numargs(@lexer.max_numparam) : val[1]
+                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
                       result = [ args, val[3] ]
 
-                      @lexer.max_numparam_stack.pop
+                      @max_numparam_stack.pop
                       @static_env.unextend
                       @lexer.cmdarg.pop
                     }
 
      f_larglist: tLPAREN2 f_args opt_bv_decl tRPAREN
                     {
-                      @lexer.max_numparam_stack.cant_have_numparams!
+                      @max_numparam_stack.has_ordinary_params!
                       result = @builder.args(val[0], val[1].concat(val[2]), val[3])
                     }
                 | f_args
                     {
                       if val[0].any?
-                        @lexer.max_numparam_stack.cant_have_numparams!
+                        @max_numparam_stack.has_ordinary_params!
                       end
                       result = @builder.args(nil, val[0], nil)
                     }
@@ -1672,30 +1699,30 @@ opt_block_args_tail:
 
       brace_body:   {
                       @static_env.extend_dynamic
-                      @lexer.max_numparam_stack.push
+                      @max_numparam_stack.push
                     }
                     opt_block_param compstmt
                     {
-                      args = @lexer.max_numparam > 0 ? @builder.numargs(@lexer.max_numparam) : val[1]
+                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
                       result = [ args, val[2] ]
 
-                      @lexer.max_numparam_stack.pop
+                      @max_numparam_stack.pop
                       @static_env.unextend
                     }
 
          do_body:   {
                       @static_env.extend_dynamic
-                      @lexer.max_numparam_stack.push
+                      @max_numparam_stack.push
                     }
                     {
                       @lexer.cmdarg.push(false)
                     }
                     opt_block_param bodystmt
                     {
-                      args = @lexer.max_numparam > 0 ? @builder.numargs(@lexer.max_numparam) : val[2]
+                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
                       result = [ args, val[3] ]
 
-                      @lexer.max_numparam_stack.pop
+                      @max_numparam_stack.pop
                       @static_env.unextend
                       @lexer.cmdarg.pop
                     }
@@ -1712,6 +1739,387 @@ opt_block_args_tail:
                     }
                 | case_body
 
+     p_case_body: kIN
+                    {
+                      @lexer.state = :expr_beg
+                      @lexer.command_start = false
+                      @pattern_variables.push
+                      @pattern_hash_keys.push
+
+                      result = @lexer.in_kwarg
+                      @lexer.in_kwarg = true
+                    }
+                  p_top_expr then
+                    {
+                      @lexer.in_kwarg = val[1]
+                    }
+                  compstmt p_cases
+                    {
+                      result = [ @builder.in_pattern(val[0], *val[2], val[3], val[5]),
+                                 *val[6] ]
+                    }
+
+         p_cases: opt_else
+                    {
+                      result = [ val[0] ]
+                    }
+                | p_case_body
+
+      p_top_expr: p_top_expr_body
+                    {
+                      result = [ val[0], nil ]
+                    }
+                | p_top_expr_body kIF_MOD expr_value
+                    {
+                      result = [ val[0], @builder.if_guard(val[1], val[2]) ]
+                    }
+                | p_top_expr_body kUNLESS_MOD expr_value
+                    {
+                      result = [ val[0], @builder.unless_guard(val[1], val[2]) ]
+                    }
+
+ p_top_expr_body: p_expr
+                | p_expr tCOMMA
+                    {
+                      # array patterns that end with comma
+                      # like 1, 2,
+                      # must be emitted as `array_pattern_with_tail`
+                      item = @builder.match_with_trailing_comma(val[0])
+                      result = @builder.array_pattern(nil, [ item ], nil)
+                    }
+                | p_expr tCOMMA p_args
+                    {
+                      result = @builder.array_pattern(nil, [val[0]].concat(val[2]), nil)
+                    }
+                | p_args_tail
+                    {
+                      result = @builder.array_pattern(nil, val[0], nil)
+                    }
+                | p_kwargs
+                    {
+                      result = @builder.hash_pattern(nil, val[0], nil)
+                    }
+
+          p_expr: p_as
+
+            p_as: p_expr tASSOC p_variable
+                    {
+                      result = @builder.match_as(val[0], val[1], val[2])
+                    }
+                | p_alt
+
+           p_alt: p_alt tPIPE p_expr_basic
+                    {
+                      result = @builder.match_alt(val[0], val[1], val[2])
+                    }
+                | p_expr_basic
+
+        p_lparen: tLPAREN2
+                    {
+                      result = val[0]
+                      @pattern_hash_keys.push
+                    }
+
+      p_lbracket: tLBRACK2
+                    {
+                      result = val[0]
+                      @pattern_hash_keys.push
+                    }
+
+    p_expr_basic: p_value
+                | p_const p_lparen p_args rparen
+                    {
+                      @pattern_hash_keys.pop
+                      pattern = @builder.array_pattern(nil, val[2], nil)
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])
+                    }
+                | p_const p_lparen p_kwargs rparen
+                    {
+                      @pattern_hash_keys.pop
+                      pattern = @builder.hash_pattern(nil, val[2], nil)
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])
+                    }
+                | p_const tLPAREN2 rparen
+                    {
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
+                    }
+                | p_const p_lbracket p_args rbracket
+                    {
+                      @pattern_hash_keys.pop
+                      pattern = @builder.array_pattern(nil, val[2], nil)
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])
+                    }
+                | p_const p_lbracket p_kwargs rbracket
+                    {
+                      @pattern_hash_keys.pop
+                      pattern = @builder.hash_pattern(nil, val[2], nil)
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])
+                    }
+                | p_const tLBRACK2 rbracket
+                    {
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
+                    }
+                | tLBRACK
+                    {
+                      @pattern_hash_keys.push
+                    }
+                  p_args rbracket
+                    {
+                      @pattern_hash_keys.pop
+                      result = @builder.array_pattern(val[0], val[2], val[3])
+                    }
+                | tLBRACK rbracket
+                    {
+                      result = @builder.array_pattern(val[0], [], val[1])
+                    }
+                | tLBRACE
+                    {
+                      @pattern_hash_keys.push
+                    }
+                  p_kwargs tRCURLY
+                    {
+                      @pattern_hash_keys.pop
+                      result = @builder.hash_pattern(val[0], val[2], val[3])
+                    }
+                | tLBRACE tRCURLY
+                    {
+                      result = @builder.hash_pattern(val[0], [], val[1])
+                    }
+                | tLPAREN
+                    {
+                      @pattern_hash_keys.push
+                    }
+                  p_expr rparen
+                    {
+                      @pattern_hash_keys.pop
+                      result = @builder.begin(val[0], val[2], val[3])
+                    }
+
+          p_args: p_expr
+                    {
+                      result = [ val[0] ]
+                    }
+                | p_args_head
+                    {
+                      result = val[0]
+                    }
+                | p_args_head p_arg
+                    {
+                      result = [ *val[0], val[1] ]
+                    }
+                | p_args_head tSTAR tIDENTIFIER
+                    {
+                      match_rest = @builder.match_rest(val[1], val[2])
+                      result = [ *val[0], match_rest ]
+                    }
+                | p_args_head tSTAR tIDENTIFIER tCOMMA p_args_post
+                    {
+                      match_rest = @builder.match_rest(val[1], val[2])
+                      result = [ *val[0], match_rest, *val[4] ]
+                    }
+                | p_args_head tSTAR
+                    {
+                      result = [ *val[0], @builder.match_rest(val[1]) ]
+                    }
+                | p_args_head tSTAR tCOMMA p_args_post
+                    {
+                      result = [ *val[0], @builder.match_rest(val[1]), *val[3] ]
+                    }
+                | p_args_tail
+
+     p_args_head: p_arg tCOMMA
+                    {
+                      # array patterns that end with comma
+                      # like [1, 2,]
+                      # must be emitted as `array_pattern_with_tail`
+                      item = @builder.match_with_trailing_comma(val[0])
+                      result = [ item ]
+                    }
+                | p_args_head p_arg tCOMMA
+                    {
+                      # array patterns that end with comma
+                      # like [1, 2,]
+                      # must be emitted as `array_pattern_with_tail`
+                      last_item = @builder.match_with_trailing_comma(val[1])
+                      result = [ *val[0], last_item ]
+                    }
+
+     p_args_tail: tSTAR tIDENTIFIER
+                    {
+                      match_rest = @builder.match_rest(val[0], val[1])
+                      result = [ match_rest ]
+                    }
+                | tSTAR tIDENTIFIER tCOMMA p_args_post
+                    {
+                      match_rest = @builder.match_rest(val[0], val[1])
+                      result = [ match_rest, *val[3] ]
+                    }
+                | tSTAR
+                    {
+                      match_rest = @builder.match_rest(val[0])
+                      result = [ match_rest ]
+                    }
+                | tSTAR tCOMMA p_args_post
+                    {
+                      match_rest = @builder.match_rest(val[0])
+                      result = [ match_rest, *val[2] ]
+                    }
+
+     p_args_post: p_arg
+                    {
+                      result = [ val[0] ]
+                    }
+                | p_args_post tCOMMA p_arg
+                    {
+                      result = [ *val[0], val[2] ]
+                    }
+
+           p_arg: p_expr
+
+        p_kwargs: p_kwarg tCOMMA p_kwrest
+                    {
+                      result = [ *val[0], *val[2] ]
+                    }
+                | p_kwarg
+                    {
+                      result = val[0]
+                    }
+                | p_kwrest
+                    {
+                      result = val[0]
+                    }
+                | p_kwarg tCOMMA p_kwnorest
+                    {
+                      result = [ *val[0], *val[2] ]
+                    }
+                | p_kwnorest
+                    {
+                      result = [ *val[0], *val[2] ]
+                    }
+
+         p_kwarg: p_kw
+                    {
+                      result = [ val[0] ]
+                    }
+                | p_kwarg tCOMMA p_kw
+                    {
+                      result = [ *val[0], val[2] ]
+                    }
+
+            p_kw: p_kw_label p_expr
+                    {
+                      result = @builder.match_pair(*val[0], val[1])
+                    }
+                | p_kw_label
+                    {
+                      result = @builder.match_label(*val[0])
+                    }
+
+      p_kw_label: tLABEL
+                  {
+                    check_kwarg_name(val[0])
+                    result = [:label, val[0]]
+                  }
+                | tSTRING_BEG string_contents tLABEL_END
+                  {
+                    result = [:quoted, [val[0], val[1], val[2]]]
+                  }
+
+        p_kwrest: kwrest_mark tIDENTIFIER
+                    {
+                      result = [ @builder.match_rest(val[0], val[1]) ]
+                    }
+                | kwrest_mark
+                    {
+                      result = [ @builder.match_rest(val[0], nil) ]
+                    }
+
+      p_kwnorest: kwrest_mark kNIL
+                    {
+                      result = [ @builder.match_nil_pattern(val[0], val[1]) ]
+                    }
+
+         p_value: p_primitive
+                | p_primitive tDOT2 p_primitive
+                    {
+                      result = @builder.range_inclusive(val[0], val[1], val[2])
+                    }
+                | p_primitive tDOT3 p_primitive
+                    {
+                      result = @builder.range_exclusive(val[0], val[1], val[2])
+                    }
+                | p_primitive tDOT2
+                    {
+                      result = @builder.range_inclusive(val[0], val[1], nil)
+                    }
+                | p_primitive tDOT3
+                    {
+                      result = @builder.range_exclusive(val[0], val[1], nil)
+                    }
+                | p_variable
+                | p_var_ref
+                | p_const
+                | tBDOT2 p_primitive
+                    {
+                      result = @builder.range_inclusive(nil, val[0], val[1])
+                    }
+                | tBDOT3 p_primitive
+                    {
+                      result = @builder.range_exclusive(nil, val[0], val[1])
+                    }
+
+     p_primitive: literal
+                | strings
+                | xstring
+                | regexp
+                | words
+                | qwords
+                | symbols
+                | qsymbols
+                | keyword_variable
+                    {
+                      result = @builder.accessible(val[0])
+                    }
+                | tLAMBDA lambda
+                    {
+                      lambda_call = @builder.call_lambda(val[0])
+
+                      args, (begin_t, body, end_t) = val[1]
+                      result      = @builder.block(lambda_call,
+                                      begin_t, args, body, end_t)
+                    }
+
+      p_variable: tIDENTIFIER
+                    {
+                      result = @builder.match_var(val[0])
+                    }
+
+       p_var_ref: tCARET tIDENTIFIER
+                    {
+                      name = val[1][0]
+                      unless static_env.declared?(name)
+                        diagnostic :error, :undefined_lvar, { :name => name }, val[1]
+                      end
+
+                      lvar = @builder.accessible(@builder.ident(val[1]))
+                      result = @builder.pin(val[0], lvar)
+                    }
+
+         p_const: tCOLON3 cname
+                    {
+                      result = @builder.const_global(val[0], val[1])
+                    }
+                | p_const tCOLON2 cname
+                    {
+                      result = @builder.const_fetch(val[0], val[1], val[2])
+                    }
+                | tCONSTANT
+                   {
+                      result = @builder.const(val[0])
+                   }
+
       opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
                     {
                       assoc_t, exc_var = val[2]
@@ -1918,10 +2326,6 @@ regexp_contents: # nothing
                     {
                       result = @builder.cvar(val[0])
                     }
-                | tNUMPARAM
-                    {
-                      result = @builder.numparam(val[0])
-                    }
                 | backref
 
           symbol: ssym
@@ -1994,10 +2398,6 @@ regexp_contents: # nothing
                     {
                       result = @builder.cvar(val[0])
                     }
-                | tNUMPARAM
-                    {
-                      result = @builder.numparam(val[0])
-                    }
 
 keyword_variable: kNIL
                     {
@@ -2030,6 +2430,46 @@ keyword_variable: kNIL
 
          var_ref: user_variable
                     {
+                      if (node = val[0]) && node.type == :ident
+                        name = node.children[0]
+
+                        if name =~ /\A_[1-9]\z/ && !static_env.declared?(name) && context.in_dynamic_block?
+                          # definitely an implicit param
+                          location = node.loc.expression
+
+                          if max_numparam_stack.has_ordinary_params?
+                            diagnostic :error, :ordinary_param_defined, nil, [nil, location]
+                          end
+
+                          raw_context = context.stack.dup
+                          raw_max_numparam_stack = max_numparam_stack.stack.dup
+
+                          # ignore current block scope
+                          raw_context.pop
+                          raw_max_numparam_stack.pop
+
+                          raw_context.reverse_each do |outer_scope|
+                            if outer_scope == :block || outer_scope == :lambda
+                              outer_scope_has_numparams = raw_max_numparam_stack.pop > 0
+
+                              if outer_scope_has_numparams
+                                diagnostic :error, :numparam_used_in_outer_scope, nil, [nil, location]
+                              else
+                                # for now it's ok, but an outer scope can also be a block
+                                # with numparams, so we need to continue
+                              end
+                            else
+                              # found an outer scope that can't have numparams
+                              # like def/class/etc
+                              break
+                            end
+                          end
+
+                          static_env.declare(name)
+                          max_numparam_stack.register(name[1].to_i)
+                        end
+                      end
+
                       result = @builder.accessible(val[0])
                     }
                 | keyword_variable
@@ -2072,6 +2512,13 @@ keyword_variable: kNIL
                     {
                       result = @builder.args(val[0], val[1], val[2])
 
+                      @lexer.state = :expr_value
+                    }
+                | tLPAREN2 args_forward rparen
+                    {
+                      result = @builder.forward_args(val[0], val[1], val[2])
+                      @static_env.declare_forward_args
+
                       @lexer.state = :expr_value
                     }
                 |   {
@@ -2204,6 +2651,11 @@ keyword_variable: kNIL
                       result = []
                     }
 
+    args_forward: tBDOT3
+                    {
+                      result = val[0]
+                    }
+
        f_bad_arg: tCONSTANT
                     {
                       diagnostic :error, :argument_const, nil, val[0]
@@ -2226,18 +2678,20 @@ keyword_variable: kNIL
                     {
                       @static_env.declare val[0][0]
 
-                      @lexer.max_numparam_stack.cant_have_numparams!
+                      @max_numparam_stack.has_ordinary_params!
 
                       result = val[0]
                     }
 
       f_arg_asgn: f_norm_arg
                     {
+                      @current_arg_stack.set(val[0][0])
                       result = val[0]
                     }
 
       f_arg_item: f_arg_asgn
                     {
+                      @current_arg_stack.set(0)
                       result = @builder.arg(val[0])
                     }
                 | tLPAREN f_margs rparen
@@ -2260,17 +2714,21 @@ keyword_variable: kNIL
 
                       @static_env.declare val[0][0]
 
-                      @lexer.max_numparam_stack.cant_have_numparams!
+                      @max_numparam_stack.has_ordinary_params!
+
+                      @current_arg_stack.set(val[0][0])
 
                       result = val[0]
                     }
 
             f_kw: f_label arg_value
                     {
+                      @current_arg_stack.set(nil)
                       result = @builder.kwoptarg(val[0], val[1])
                     }
                 | f_label
                     {
+                      @current_arg_stack.set(nil)
                       result = @builder.kwarg(val[0])
                     }
 
@@ -2321,11 +2779,13 @@ keyword_variable: kNIL
 
            f_opt: f_arg_asgn tEQL arg_value
                     {
+                      @current_arg_stack.set(0)
                       result = @builder.optarg(val[0], val[1], val[2])
                     }
 
      f_block_opt: f_arg_asgn tEQL primary_value
                     {
+                      @current_arg_stack.set(0)
                       result = @builder.optarg(val[0], val[1], val[2])
                     }