parser 2.5.1.0 → 3.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d4445244332537a2a91b8b6f6a2d35b750ffb1dbc3869c91f1a4de840a89600
-  data.tar.gz: 800b3adeae6c64459f2b604c3c4b935eb728018bfe4136debae16c96df0384bf
+  metadata.gz: 6c85d02ca4bf90dcc1d33424dd323ae54b9e60581a6473012e950f82ce15d28e
+  data.tar.gz: ebe2c4eb02779209b8a34e051d717a6af84da81fadfeff79d9eab194ecf95d93
 SHA512:
-  metadata.gz: 99138e99f88e016a3da7cac3fe45c492068fe5fa5ecb6df640ade2f6890c05fdc2aff096d255e0fd57f75f4e5c3300c15f16fa9be177e9fdc56711c6e6ea29ac
-  data.tar.gz: 71504873b9c22a3adfd0d0ee304e69e3317b93d52a7e2506c6225e2c768cea2ddd9bf1a874a04c8b0706047f78dc97f49b7841307f64198678f03a3336ad2675
+  metadata.gz: 173d8e1bbbbbf0ef06d06f1ea59dc41ca49c8b39c6931523dc70bac259eee1e9c9263730d560afe106c70f88f01ae14edc77862d20a4924a674131ca90b9807c
+  data.tar.gz: 1698922a4ff14bf3e826f10b826a8a8e0c3aaf7fefd20669a4666c0ed6ea8a3ed405acbb28fe90985510dedff6414c0330d5affa4639840178bf20dee561e4a9

data/lib/parser.rb

@@ -46,6 +46,7 @@ module Parser
     require 'parser/source/map/variable'
     require 'parser/source/map/keyword'
     require 'parser/source/map/definition'
+    require 'parser/source/map/method_definition'
     require 'parser/source/map/send'
     require 'parser/source/map/index'
     require 'parser/source/map/condition'
@@ -73,6 +74,9 @@ module Parser
   end
 
   require 'parser/context'
+  require 'parser/max_numparam_stack'
+  require 'parser/current_arg_stack'
+  require 'parser/variables_stack'
 
   require 'parser/base'
 

data/lib/parser/all.rb

@@ -9,3 +9,6 @@ require 'parser/ruby23'
 require 'parser/ruby24'
 require 'parser/ruby25'
 require 'parser/ruby26'
+require 'parser/ruby27'
+require 'parser/ruby30'
+require 'parser/ruby31'

data/lib/parser/ast/processor.rb

@@ -16,9 +16,11 @@ module Parser
       alias on_regexp   process_regular_node
       alias on_xstr     process_regular_node
       alias on_splat    process_regular_node
+      alias on_kwsplat  process_regular_node
       alias on_array    process_regular_node
       alias on_pair     process_regular_node
       alias on_hash     process_regular_node
+      alias on_kwargs   process_regular_node
       alias on_irange   process_regular_node
       alias on_erange   process_regular_node
 
@@ -123,7 +125,23 @@ module Parser
       alias on_kwarg          process_argument_node
       alias on_kwoptarg       process_argument_node
       alias on_kwrestarg      process_argument_node
-      alias on_procarg0       process_argument_node
+      alias on_forward_arg    process_argument_node
+
+      def on_procarg0(node)
+        if node.children[0].is_a?(Symbol)
+          # This branch gets executed when the builder
+          # is not configured to emit and 'arg' inside 'procarg0', i.e. when
+          #   Parser::Builders::Default.emit_arg_inside_procarg0
+          # is set to false.
+          #
+          # If this flag is set to true this branch is unreachable.
+          # s(:procarg0, :a)
+          on_argument(node)
+        else
+          # s(:procarg0, s(:arg, :a), s(:arg, :b))
+          process_regular_node(node)
+        end
+      end
 
       alias on_arg_expr       process_regular_node
       alias on_restarg_expr   process_regular_node
@@ -172,6 +190,14 @@ module Parser
       alias on_block    process_regular_node
       alias on_lambda   process_regular_node
 
+      def on_numblock(node)
+        method_call, max_numparam, body = *node
+
+        node.updated(nil, [
+          process(method_call), max_numparam, process(body)
+        ])
+      end
+
       alias on_while      process_regular_node
       alias on_while_post process_regular_node
       alias on_until      process_regular_node
@@ -212,6 +238,24 @@ module Parser
       alias on_preexe   process_regular_node
       alias on_postexe  process_regular_node
 
+      alias on_case_match              process_regular_node
+      alias on_in_match                process_regular_node
+      alias on_match_pattern           process_regular_node
+      alias on_match_pattern_p         process_regular_node
+      alias on_in_pattern              process_regular_node
+      alias on_if_guard                process_regular_node
+      alias on_unless_guard            process_regular_node
+      alias on_match_var               process_variable_node
+      alias on_match_rest              process_regular_node
+      alias on_pin                     process_regular_node
+      alias on_match_alt               process_regular_node
+      alias on_match_as                process_regular_node
+      alias on_array_pattern           process_regular_node
+      alias on_array_pattern_with_tail process_regular_node
+      alias on_hash_pattern            process_regular_node
+      alias on_const_pattern           process_regular_node
+      alias on_find_pattern            process_regular_node
+
       # @private
       def process_variable_node(node)
         warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
@@ -235,6 +279,10 @@ module Parser
           'Parser::AST::Processor#on_argument instead.'
         on_argument(node)
       end
+
+      def on_empty_else(node)
+        node
+      end
     end
   end
 end

data/lib/parser/base.rb

@@ -109,11 +109,16 @@ module Parser
     end
     private_class_method :setup_source_buffer
 
+    attr_reader :lexer
     attr_reader :diagnostics
     attr_reader :builder
     attr_reader :static_env
     attr_reader :source_buffer
     attr_reader :context
+    attr_reader :max_numparam_stack
+    attr_reader :current_arg_stack
+    attr_reader :pattern_variables
+    attr_reader :pattern_hash_keys
 
     ##
     # @param [Parser::Builders::Default] builder The AST builder to use.
@@ -123,13 +128,28 @@ module Parser
 
       @static_env  = StaticEnvironment.new
 
+      # Stack that holds current parsing context
+      @context = Context.new
+
+      # Maximum numbered parameters stack
+      @max_numparam_stack = MaxNumparamStack.new
+
+      # Current argument names stack
+      @current_arg_stack = CurrentArgStack.new
+
+      # Stack of set of variables used in the current pattern
+      @pattern_variables = VariablesStack.new
+
+      # Stack of set of keys used in the current hash in pattern matchinig
+      @pattern_hash_keys = VariablesStack.new
+
       @lexer = Lexer.new(version)
       @lexer.diagnostics = @diagnostics
       @lexer.static_env  = @static_env
+      @lexer.context     = @context
 
       @builder = builder
       @builder.parser = self
-      @context = Context.new
 
       # Last emitted token
       @last_token = nil
@@ -150,21 +170,24 @@ module Parser
       @lexer.reset
       @static_env.reset
       @context.reset
+      @current_arg_stack.reset
+      @pattern_variables.reset
+      @pattern_hash_keys.reset
 
       self
     end
 
     ##
-    # Parses a source buffer and returns the AST.
+    # Parses a source buffer and returns the AST, or `nil` in case of a non fatal error.
     #
     # @param [Parser::Source::Buffer] source_buffer The source buffer to parse.
-    # @return [Parser::AST::Node]
+    # @return [Parser::AST::Node, nil]
     #
     def parse(source_buffer)
       @lexer.source_buffer = source_buffer
       @source_buffer       = source_buffer
 
-      do_parse
+      do_parse || nil # Force `false` to `nil`, see https://github.com/ruby/racc/pull/136
     ensure
       # Don't keep references to the source file.
       @source_buffer       = nil
@@ -188,8 +211,9 @@ module Parser
 
     ##
     # Parses a source buffer and returns the AST, the source code comments,
-    # and the tokens emitted by the lexer. If `recover` is true and a fatal
-    # {SyntaxError} is encountered, `nil` is returned instead of the AST, and
+    # and the tokens emitted by the lexer. In case of a fatal error, a {SyntaxError}
+    # is raised, unless `recover` is true. In case of an error
+    # (non-fatal or recovered), `nil` is returned instead of the AST, and
     # comments as well as tokens are only returned up to the location of
     # the error.
     #

data/lib/parser/builders/default.rb

@@ -82,6 +82,129 @@ module Parser
 
     @emit_index = false
 
+    class << self
+      ##
+      # AST compatibility attribute; causes a single non-mlhs
+      # block argument to be wrapped in s(:procarg0).
+      #
+      # If set to false (the default), block arguments `|a|` are emitted as
+      # `s(:args, s(:procarg0, :a))`
+      #
+      # If set to true, block arguments `|a|` are emitted as
+      # `s(:args, s(:procarg0, s(:arg, :a))`
+      #
+      # @return [Boolean]
+      attr_accessor :emit_arg_inside_procarg0
+    end
+
+    @emit_arg_inside_procarg0 = false
+
+    class << self
+      ##
+      # AST compatibility attribute; arguments forwarding initially
+      # didn't have support for leading arguments
+      # (i.e. `def m(a, ...); end` was a syntax error). However, Ruby 3.0
+      # added support for any number of arguments in front of the `...`.
+      #
+      # If set to false (the default):
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:forward_args), nil)
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m,
+      #        s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # If set to true it uses a single format:
+      #   1. `def m(...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:forward_arg)))
+      #   2. `def m(a, b, ...) end` is emitted as
+      #      s(:def, :m, s(:args, s(:arg, :a), s(:arg, :b), s(:forward_arg)))
+      #
+      # It does't matter that much on 2.7 (because there can't be any leading arguments),
+      # but on 3.0 it should be better enabled to use a single AST format.
+      #
+      # @return [Boolean]
+      attr_accessor :emit_forward_arg
+    end
+
+    @emit_forward_arg = false
+
+    class << self
+      ##
+      # AST compatibility attribute; Starting from Ruby 2.7 keyword arguments
+      # of method calls that are passed explicitly as a hash (i.e. with curly braces)
+      # are treated as positional arguments and Ruby 2.7 emits a warning on such method
+      # call. Ruby 3.0 given an ArgumentError.
+      #
+      # If set to false (the default) the last hash argument is emitted as `hash`:
+      #
+      # ```
+      # (send nil :foo
+      #   (hash
+      #     (pair
+      #       (sym :bar)
+      #       (int 42))))
+      # ```
+      #
+      # If set to true it is emitted as `kwargs`:
+      #
+      # ```
+      # (send nil :foo
+      #   (kwargs
+      #     (pair
+      #       (sym :bar)
+      #       (int 42))))
+      # ```
+      #
+      # Note that `kwargs` node is just a replacement for `hash` argument,
+      # so if there's are multiple arguments (or a `kwsplat`) all of them
+      # are wrapped into `kwargs` instead of `hash`:
+      #
+      # ```
+      # (send nil :foo
+      #   (hash
+      #     (pair
+      #       (sym :a)
+      #       (int 42))
+      #     (kwsplat
+      #       (send nil :b))
+      #     (pair
+      #       (sym :c)
+      #       (int 10))))
+      # ```
+      attr_accessor :emit_kwargs
+    end
+
+    @emit_kwargs = false
+
+    class << self
+      ##
+      # AST compatibility attribute; Starting from 3.0 Ruby returns
+      # true/false from single-line pattern matching with `in` keyword.
+      #
+      # Before 3.0 there was an exception if given value doesn't match pattern.
+      #
+      # NOTE: This attribute affects only Ruby 2.7 grammar.
+      # 3.0 grammar always emits `match_pattern`/`match_pattern_p`
+      #
+      # If compatibility attribute set to false `foo in bar` is emitted as `in_match`:
+      #
+      # ```
+      # (in-match
+      #   (send nil :foo)
+      #   (match-var :bar))
+      # ```
+      #
+      # If set to true it's emitted as `match_pattern_p`:
+      # ```
+      # (match-pattern-p
+      #   (send nil :foo)
+      #   (match-var :bar))
+      # ```
+      attr_accessor :emit_match_pattern
+    end
+
+    @emit_match_pattern = false
+
     class << self
       ##
       # @api private
@@ -90,6 +213,10 @@ module Parser
         @emit_procarg0 = true
         @emit_encoding = true
         @emit_index = true
+        @emit_arg_inside_procarg0 = true
+        @emit_forward_arg = true
+        @emit_kwargs = true
+        @emit_match_pattern = true
       end
     end
 
@@ -262,18 +389,23 @@ module Parser
       if !dedent_level.nil?
         dedenter = Lexer::Dedenter.new(dedent_level)
 
-        if node.type == :str
+        case node.type
+        when :str
           str = node.children.first
           dedenter.dedent(str)
-        elsif node.type == :dstr || node.type == :xstr
-          node.children.each do |str_node|
+        when :dstr, :xstr
+          children = node.children.map do |str_node|
             if str_node.type == :str
               str = str_node.children.first
               dedenter.dedent(str)
+              next nil if str.empty?
             else
               dedenter.interrupt
             end
+            str_node
           end
+
+          node = node.updated(nil, children.compact)
         end
       end
 
@@ -400,12 +532,12 @@ module Parser
 
     def range_inclusive(lhs, dot2_t, rhs)
       n(:irange, [ lhs, rhs ],
-        binary_op_map(lhs, dot2_t, rhs))
+        range_map(lhs, dot2_t, rhs))
     end
 
     def range_exclusive(lhs, dot3_t, rhs)
       n(:erange, [ lhs, rhs ],
-        binary_op_map(lhs, dot3_t, rhs))
+        range_map(lhs, dot3_t, rhs))
     end
 
     #
@@ -477,6 +609,11 @@ module Parser
         name, = *node
 
         if @parser.static_env.declared?(name)
+          if name.to_s == parser.current_arg_stack.top
+            diagnostic :error, :circular_argument_reference,
+                       { :var_name => name.to_s }, node.loc.expression
+          end
+
           node.updated(:lvar)
         else
           name, = *node
@@ -535,6 +672,13 @@ module Parser
 
       when :ident
         name, = *node
+
+        var_name = node.children[0].to_s
+        name_loc = node.loc.expression
+
+        check_assignment_to_numparam(var_name, name_loc)
+        check_reserved_for_numparam(var_name, name_loc)
+
         @parser.static_env.declare(name)
 
         node.updated(:lvasgn)
@@ -624,23 +768,38 @@ module Parser
 
     def def_method(def_t, name_t, args,
                    body, end_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:def, [ value(name_t).to_sym, args, body ],
         definition_map(def_t, nil, name_t, end_t))
     end
 
+    def def_endless_method(def_t, name_t, args,
+                           assignment_t, body)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
+      n(:def, [ value(name_t).to_sym, args, body ],
+        endless_definition_map(def_t, nil, name_t, assignment_t, body))
+    end
+
     def def_singleton(def_t, definee, dot_t,
                       name_t, args,
                       body, end_t)
-      case definee.type
-      when :int, :str, :dstr, :sym, :dsym,
-           :regexp, :array, :hash
+      validate_definee(definee)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
 
-        diagnostic :error, :singleton_literal, nil, definee.loc.expression
+      n(:defs, [ definee, value(name_t).to_sym, args, body ],
+        definition_map(def_t, dot_t, name_t, end_t))
+    end
 
-      else
-        n(:defs, [ definee, value(name_t).to_sym, args, body ],
-          definition_map(def_t, dot_t, name_t, end_t))
-      end
+    def def_endless_singleton(def_t, definee, dot_t,
+                              name_t, args,
+                              assignment_t, body)
+      validate_definee(definee)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
+      n(:defs, [ definee, value(name_t).to_sym, args, body ],
+        endless_definition_map(def_t, dot_t, name_t, assignment_t, body))
     end
 
     def undef_method(undef_t, names)
@@ -663,12 +822,34 @@ module Parser
         collection_map(begin_t, args, end_t))
     end
 
+    def numargs(max_numparam)
+      n(:numargs, [ max_numparam ], nil)
+    end
+
+    def forward_only_args(begin_t, dots_t, end_t)
+      if self.class.emit_forward_arg
+        arg = forward_arg(dots_t)
+        n(:args, [ arg ],
+          collection_map(begin_t, [ arg ], end_t))
+      else
+        n(:forward_args, [], collection_map(begin_t, token_map(dots_t), end_t))
+      end
+    end
+
+    def forward_arg(dots_t)
+      n(:forward_arg, [], token_map(dots_t))
+    end
+
     def arg(name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:arg, [ value(name_t).to_sym ],
         variable_map(name_t))
     end
 
     def optarg(name_t, eql_t, value)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:optarg, [ value(name_t).to_sym, value ],
         variable_map(name_t).
           with_operator(loc(eql_t)).
@@ -677,6 +858,7 @@ module Parser
 
     def restarg(star_t, name_t=nil)
       if name_t
+        check_reserved_for_numparam(value(name_t), loc(name_t))
         n(:restarg, [ value(name_t).to_sym ],
           arg_prefix_map(star_t, name_t))
       else
@@ -686,17 +868,23 @@ module Parser
     end
 
     def kwarg(name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:kwarg, [ value(name_t).to_sym ],
         kwarg_map(name_t))
     end
 
     def kwoptarg(name_t, value)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:kwoptarg, [ value(name_t).to_sym, value ],
         kwarg_map(name_t, value))
     end
 
     def kwrestarg(dstar_t, name_t=nil)
       if name_t
+        check_reserved_for_numparam(value(name_t), loc(name_t))
+
         n(:kwrestarg, [ value(name_t).to_sym ],
           arg_prefix_map(dstar_t, name_t))
       else
@@ -705,19 +893,33 @@ module Parser
       end
     end
 
+    def kwnilarg(dstar_t, nil_t)
+      n0(:kwnilarg,
+        arg_prefix_map(dstar_t, nil_t))
+    end
+
     def shadowarg(name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:shadowarg, [ value(name_t).to_sym ],
         variable_map(name_t))
     end
 
     def blockarg(amper_t, name_t)
+      check_reserved_for_numparam(value(name_t), loc(name_t))
+
       n(:blockarg, [ value(name_t).to_sym ],
         arg_prefix_map(amper_t, name_t))
     end
 
     def procarg0(arg)
       if self.class.emit_procarg0
-        arg.updated(:procarg0)
+        if arg.type == :arg && self.class.emit_arg_inside_procarg0
+          n(:procarg0, [ arg ],
+            Source::Map::Collection.new(nil, nil, arg.location.expression))
+        else
+          arg.updated(:procarg0)
+        end
       else
         arg
       end
@@ -802,9 +1004,18 @@ module Parser
       end
     end
 
+    def forwarded_args(dots_t)
+      n(:forwarded_args, [], token_map(dots_t))
+    end
+
     def call_method(receiver, dot_t, selector_t,
                     lparen_t=nil, args=[], rparen_t=nil)
       type = call_type_for_dot(dot_t)
+
+      if self.class.emit_kwargs
+        rewrite_hash_args_to_kwargs(args)
+      end
+
       if selector_t.nil?
         n(type, [ receiver, :call, *args ],
           send_map(receiver, dot_t, nil, lparen_t, args, rparen_t))
@@ -831,19 +1042,26 @@ module Parser
       end
 
       last_arg = call_args.last
-      if last_arg && last_arg.type == :block_pass
+      if last_arg && (last_arg.type == :block_pass || last_arg.type == :forwarded_args)
         diagnostic :error, :block_and_blockarg, nil, last_arg.loc.expression, [loc(begin_t)]
       end
 
+      if args.type == :numargs
+        block_type = :numblock
+        args = args.children[0]
+      else
+        block_type = :block
+      end
+
       if [:send, :csend, :index, :super, :zsuper, :lambda].include?(method_call.type)
-        n(:block, [ method_call, args, body ],
+        n(block_type, [ method_call, args, body ],
           block_map(method_call.loc.expression, begin_t, end_t))
       else
         # Code like "return foo 1 do end" is reduced in a weird sequence.
         # Here, method_call is actually (return).
         actual_send, = *method_call
         block =
-          n(:block, [ actual_send, args, body ],
+          n(block_type, [ actual_send, args, body ],
             block_map(actual_send.loc.expression, begin_t, end_t))
 
         n(method_call.type, [ block ],
@@ -875,6 +1093,10 @@ module Parser
     end
 
     def index(receiver, lbrack_t, indexes, rbrack_t)
+      if self.class.emit_kwargs
+        rewrite_hash_args_to_kwargs(indexes)
+      end
+
       if self.class.emit_index
         n(:index, [ receiver, *indexes ],
           index_map(receiver, lbrack_t, rbrack_t))
@@ -1037,6 +1259,10 @@ module Parser
         end
       end
 
+      if %i[yield super].include?(type) && self.class.emit_kwargs
+        rewrite_hash_args_to_kwargs(args)
+      end
+
       n(type, args,
         keyword_map(keyword_t, lparen_t, args, rparen_t))
     end
@@ -1155,6 +1381,219 @@ module Parser
       end
     end
 
+    #
+    # PATTERN MATCHING
+    #
+
+    def case_match(case_t, expr, in_bodies, else_t, else_body, end_t)
+      else_body = n(:empty_else, nil, token_map(else_t)) if else_t && !else_body
+      n(:case_match, [ expr, *(in_bodies << else_body)],
+        condition_map(case_t, expr, nil, nil, else_t, else_body, end_t))
+    end
+
+    def in_match(lhs, in_t, rhs)
+      n(:in_match, [lhs, rhs],
+        binary_op_map(lhs, in_t, rhs))
+    end
+
+    def match_pattern(lhs, match_t, rhs)
+      n(:match_pattern, [lhs, rhs],
+        binary_op_map(lhs, match_t, rhs))
+    end
+
+    def match_pattern_p(lhs, match_t, rhs)
+      n(:match_pattern_p, [lhs, rhs],
+        binary_op_map(lhs, match_t, rhs))
+    end
+
+    def in_pattern(in_t, pattern, guard, then_t, body)
+      children = [pattern, guard, body]
+      n(:in_pattern, children,
+        keyword_map(in_t, then_t, children.compact, nil))
+    end
+
+    def if_guard(if_t, if_body)
+      n(:if_guard, [if_body], guard_map(if_t, if_body))
+    end
+
+    def unless_guard(unless_t, unless_body)
+      n(:unless_guard, [unless_body], guard_map(unless_t, unless_body))
+    end
+
+    def match_var(name_t)
+      name = value(name_t).to_sym
+      name_l = loc(name_t)
+
+      check_lvar_name(name, name_l)
+      check_duplicate_pattern_variable(name, name_l)
+      @parser.static_env.declare(name)
+
+      n(:match_var, [ name ],
+        variable_map(name_t))
+    end
+
+    def match_hash_var(name_t)
+      name = value(name_t).to_sym
+
+      expr_l = loc(name_t)
+      name_l = expr_l.adjust(end_pos: -1)
+
+      check_lvar_name(name, name_l)
+      check_duplicate_pattern_variable(name, name_l)
+      @parser.static_env.declare(name)
+
+      n(:match_var, [ name ],
+        Source::Map::Variable.new(name_l, expr_l))
+    end
+
+    def match_hash_var_from_str(begin_t, strings, end_t)
+      if strings.length > 1
+        diagnostic :error, :pm_interp_in_var_name, nil, loc(begin_t).join(loc(end_t))
+      end
+
+      string = strings[0]
+
+      case string.type
+      when :str
+        # MRI supports plain strings in hash pattern matching
+        name, = *string
+        name_l = string.loc.expression
+
+        check_lvar_name(name, name_l)
+        check_duplicate_pattern_variable(name, name_l)
+
+        @parser.static_env.declare(name)
+
+        if (begin_l = string.loc.begin)
+          # exclude beginning of the string from the location of the variable
+          name_l = name_l.adjust(begin_pos: begin_l.length)
+        end
+
+        if (end_l = string.loc.end)
+          # exclude end of the string from the location of the variable
+          name_l = name_l.adjust(end_pos: -end_l.length)
+        end
+
+        expr_l = loc(begin_t).join(string.loc.expression).join(loc(end_t))
+        n(:match_var, [ name.to_sym ],
+          Source::Map::Variable.new(name_l, expr_l))
+      when :begin
+        match_hash_var_from_str(begin_t, string.children, end_t)
+      else
+        # we only can get here if there is an interpolation, e.g., ``in "#{ a }":`
+        diagnostic :error, :pm_interp_in_var_name, nil, loc(begin_t).join(loc(end_t))
+      end
+    end
+
+    def match_rest(star_t, name_t = nil)
+      if name_t.nil?
+        n0(:match_rest,
+          unary_op_map(star_t))
+      else
+        name = match_var(name_t)
+        n(:match_rest, [ name ],
+          unary_op_map(star_t, name))
+      end
+    end
+
+    def hash_pattern(lbrace_t, kwargs, rbrace_t)
+      args = check_duplicate_args(kwargs)
+      n(:hash_pattern, args,
+        collection_map(lbrace_t, args, rbrace_t))
+    end
+
+    def array_pattern(lbrack_t, elements, rbrack_t)
+      return n(:array_pattern, nil, collection_map(lbrack_t, [], rbrack_t)) if elements.nil?
+
+      trailing_comma = false
+
+      node_elements = elements.map do |element|
+        if element.type == :match_with_trailing_comma
+          trailing_comma = true
+          element.children.first
+        else
+          trailing_comma = false
+          element
+        end
+      end
+
+      node_type = trailing_comma ? :array_pattern_with_tail : :array_pattern
+
+      n(node_type, node_elements,
+        collection_map(lbrack_t, elements, rbrack_t))
+    end
+
+    def find_pattern(lbrack_t, elements, rbrack_t)
+      n(:find_pattern, elements,
+        collection_map(lbrack_t, elements, rbrack_t))
+    end
+
+    def match_with_trailing_comma(match, comma_t)
+      n(:match_with_trailing_comma, [ match ], expr_map(match.loc.expression.join(loc(comma_t))))
+    end
+
+    def const_pattern(const, ldelim_t, pattern, rdelim_t)
+      n(:const_pattern, [const, pattern],
+        Source::Map::Collection.new(
+          loc(ldelim_t), loc(rdelim_t),
+          const.loc.expression.join(loc(rdelim_t))
+        )
+      )
+    end
+
+    def pin(pin_t, var)
+      n(:pin, [ var ],
+        send_unary_op_map(pin_t, var))
+    end
+
+    def match_alt(left, pipe_t, right)
+      source_map = binary_op_map(left, pipe_t, right)
+
+      n(:match_alt, [ left, right ],
+        source_map)
+    end
+
+    def match_as(value, assoc_t, as)
+      source_map = binary_op_map(value, assoc_t, as)
+
+      n(:match_as, [ value, as ],
+        source_map)
+    end
+
+    def match_nil_pattern(dstar_t, nil_t)
+      n0(:match_nil_pattern,
+        arg_prefix_map(dstar_t, nil_t))
+    end
+
+    def match_pair(label_type, label, value)
+      if label_type == :label
+        check_duplicate_pattern_key(label[0], label[1])
+        pair_keyword(label, value)
+      else
+        begin_t, parts, end_t = label
+        label_loc = loc(begin_t).join(loc(end_t))
+
+        # quoted label like "label": value
+        if (var_name = static_string(parts))
+          check_duplicate_pattern_key(var_name, label_loc)
+        else
+          diagnostic :error, :pm_interp_in_var_name, nil, label_loc
+        end
+
+        pair_quoted(begin_t, parts, end_t, value)
+      end
+    end
+
+    def match_label(label_type, label)
+      if label_type == :label
+        match_hash_var(label)
+      else
+        # quoted label like "label": value
+        begin_t, strings, end_t = label
+        match_hash_var_from_str(begin_t, strings, end_t)
+      end
+    end
+
     private
 
     #
@@ -1210,18 +1649,18 @@ module Parser
         case this_arg.type
         when :arg, :optarg, :restarg, :blockarg,
              :kwarg, :kwoptarg, :kwrestarg,
-             :shadowarg, :procarg0
+             :shadowarg
 
-          this_name, = *this_arg
+          check_duplicate_arg(this_arg, map)
 
-          that_arg   = map[this_name]
-          that_name, = *that_arg
+        when :procarg0
 
-          if that_arg.nil?
-            map[this_name] = this_arg
-          elsif arg_name_collides?(this_name, that_name)
-            diagnostic :error, :duplicate_argument, nil,
-                       this_arg.loc.name, [ that_arg.loc.name ]
+          if this_arg.children[0].is_a?(Symbol)
+            # s(:procarg0, :a)
+            check_duplicate_arg(this_arg, map)
+          else
+            # s(:procarg0, s(:arg, :a), ...)
+            check_duplicate_args(this_arg.children, map)
           end
 
         when :mlhs
@@ -1230,6 +1669,45 @@ module Parser
       end
     end
 
+    def check_duplicate_arg(this_arg, map={})
+      this_name, = *this_arg
+
+      that_arg   = map[this_name]
+      that_name, = *that_arg
+
+      if that_arg.nil?
+        map[this_name] = this_arg
+      elsif arg_name_collides?(this_name, that_name)
+        diagnostic :error, :duplicate_argument, nil,
+                   this_arg.loc.name, [ that_arg.loc.name ]
+      end
+    end
+
+    def check_assignment_to_numparam(name, loc)
+      # MRI < 2.7 treats numbered parameters as regular variables
+      # and so it's allowed to perform assignments like `_1 = 42`.
+      return if @parser.version < 27
+
+      assigning_to_numparam =
+        @parser.context.in_dynamic_block? &&
+        name =~ /\A_([1-9])\z/ &&
+        @parser.max_numparam_stack.has_numparams?
+
+      if assigning_to_numparam
+        diagnostic :error, :cant_assign_to_numparam, { :name => name }, loc
+      end
+    end
+
+    def check_reserved_for_numparam(name, loc)
+      # MRI < 3.0 accepts assignemnt to variables like _1
+      # if it's not a numbered parameter. MRI 3.0 and newer throws an error.
+      return if @parser.version < 30
+
+      if name =~ /\A_([1-9])\z/
+        diagnostic :error, :reserved_for_numparam, { :name => name }, loc
+      end
+    end
+
     def arg_name_collides?(this_name, that_name)
       case @parser.version
       when 18
@@ -1245,6 +1723,32 @@ module Parser
       end
     end
 
+    def check_lvar_name(name, loc)
+      if name =~ /\A[[[:lower:]]_][[[:alnum:]]_]*\z/
+        # OK
+      else
+        diagnostic :error, :lvar_name, { name: name }, loc
+      end
+    end
+
+    def check_duplicate_pattern_variable(name, loc)
+      return if name.to_s.start_with?('_')
+
+      if @parser.pattern_variables.declared?(name)
+        diagnostic :error, :duplicate_variable_name, { name: name.to_s }, loc
+      end
+
+      @parser.pattern_variables.declare(name)
+    end
+
+    def check_duplicate_pattern_key(name, loc)
+      if @parser.pattern_hash_keys.declared?(name)
+        diagnostic :error, :duplicate_pattern_key, { name: name.to_s }, loc
+      end
+
+      @parser.pattern_hash_keys.declare(name)
+    end
+
     #
     # SOURCE MAPS
     #
@@ -1388,6 +1892,18 @@ module Parser
       Source::Map::Operator.new(loc(op_t), expr_l)
     end
 
+    def range_map(start_e, op_t, end_e)
+      if start_e && end_e
+        expr_l = join_exprs(start_e, end_e)
+      elsif start_e
+        expr_l = start_e.loc.expression.join(loc(op_t))
+      elsif end_e
+        expr_l = loc(op_t).join(end_e.loc.expression)
+      end
+
+      Source::Map::Operator.new(loc(op_t), expr_l)
+    end
+
     def arg_prefix_map(op_t, name_t=nil)
       if name_t.nil?
         expr_l = loc(op_t)
@@ -1422,9 +1938,17 @@ module Parser
     end
 
     def definition_map(keyword_t, operator_t, name_t, end_t)
-      Source::Map::Definition.new(loc(keyword_t),
-                                  loc(operator_t), loc(name_t),
-                                  loc(end_t))
+      Source::Map::MethodDefinition.new(loc(keyword_t),
+                                        loc(operator_t), loc(name_t),
+                                        loc(end_t), nil, nil)
+    end
+
+    def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e)
+      body_l = body_e.loc.expression
+
+      Source::Map::MethodDefinition.new(loc(keyword_t),
+                                        loc(operator_t), loc(name_t), nil,
+                                        loc(assignment_t), body_l)
     end
 
     def send_map(receiver_e, dot_t, selector_t, begin_t=nil, args=[], end_t=nil)
@@ -1581,6 +2105,13 @@ module Parser
                                  begin_l.join(end_l))
     end
 
+    def guard_map(keyword_t, guard_body_e)
+      keyword_l = loc(keyword_t)
+      guard_body_l = guard_body_e.loc.expression
+
+      Source::Map::Keyword.new(keyword_l, nil, nil, keyword_l.join(guard_body_l))
+    end
+
     #
     # HELPERS
     #
@@ -1662,6 +2193,32 @@ module Parser
         @parser.send :yyerror
       end
     end
+
+    def validate_definee(definee)
+      case definee.type
+      when :int, :str, :dstr, :sym, :dsym,
+           :regexp, :array, :hash
+
+        diagnostic :error, :singleton_literal, nil, definee.loc.expression
+        false
+      else
+        true
+      end
+    end
+
+    def rewrite_hash_args_to_kwargs(args)
+      if args.any? && kwargs?(args.last)
+        # foo(..., bar: baz)
+        args[args.length - 1] = args[args.length - 1].updated(:kwargs)
+      elsif args.length > 1 && args.last.type == :block_pass && kwargs?(args[args.length - 2])
+        # foo(..., bar: baz, &blk)
+        args[args.length - 2] = args[args.length - 2].updated(:kwargs)
+      end
+    end
+
+    def kwargs?(node)
+      node.type == :hash && node.loc.begin.nil? && node.loc.end.nil?
+    end
   end
 
 end