parser 2.6.5.0 → 2.7.0.4

data/lib/parser.rb

@@ -67,13 +67,15 @@ module Parser
   require 'parser/lexer/literal'
   require 'parser/lexer/stack_state'
   require 'parser/lexer/dedenter'
-  require 'parser/lexer/max_numparam_stack'
 
   module Builders
     require 'parser/builders/default'
   end
 
   require 'parser/context'
+  require 'parser/max_numparam_stack'
+  require 'parser/current_arg_stack'
+  require 'parser/variables_stack'
 
   require 'parser/base'
 

data/lib/parser/ast/processor.rb

@@ -236,6 +236,21 @@ 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_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
+
       # @private
       def process_variable_node(node)
         warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
@@ -259,6 +274,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

@@ -114,6 +114,10 @@ module Parser
     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.
@@ -126,6 +130,18 @@ module Parser
       # 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
@@ -153,6 +169,9 @@ module Parser
       @lexer.reset
       @static_env.reset
       @context.reset
+      @current_arg_stack.reset
+      @pattern_variables.reset
+      @pattern_hash_keys.reset
 
       self
     end

data/lib/parser/builders/default.rb

@@ -453,11 +453,6 @@ module Parser
         variable_map(token))
     end
 
-    def numparam(token)
-      n(:numparam, [ value(token).to_i ],
-        variable_map(token))
-    end
-
     def back_ref(token)
       n(:back_ref, [ value(token).to_sym ],
         token_map(token))
@@ -498,6 +493,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
@@ -556,6 +556,9 @@ module Parser
 
       when :ident
         name, = *node
+
+        check_assignment_to_numparam(node)
+
         @parser.static_env.declare(name)
 
         node.updated(:lvasgn)
@@ -688,6 +691,10 @@ module Parser
       n(:numargs, [ max_numparam ], nil)
     end
 
+    def forward_args(begin_t, dots_t, end_t)
+      n(:forward_args, [], collection_map(begin_t, token_map(dots_t), end_t))
+    end
+
     def arg(name_t)
       n(:arg, [ value(name_t).to_sym ],
         variable_map(name_t))
@@ -837,6 +844,10 @@ 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)
@@ -866,11 +877,10 @@ 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]
@@ -1006,11 +1016,6 @@ module Parser
       end
     end
 
-    def method_ref(receiver, dot_t, selector_t)
-      n(:meth_ref, [ receiver, value(selector_t).to_sym ],
-          send_map(receiver, dot_t, selector_t, nil, [], nil))
-    end
-
     #
     # Control flow
     #
@@ -1203,6 +1208,193 @@ 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 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
+
+      check_duplicate_pattern_variable(name, loc(name_t))
+      @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_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)
+      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
+
+      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, elements,
+        collection_map(lbrack_t, elements, rbrack_t))
+    end
+
+    def match_with_trailing_comma(match)
+      n(:match_with_trailing_comma, [ match ], nil)
+    end
+
+    def const_pattern(const, ldelim_t, pattern, rdelim_t)
+      n(:const_pattern, [const, pattern],
+        collection_map(ldelim_t, [pattern], 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
 
     #
@@ -1292,6 +1484,19 @@ module Parser
       end
     end
 
+    def check_assignment_to_numparam(node)
+      name = node.children[0].to_s
+
+      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 }, node.loc.expression
+      end
+    end
+
     def arg_name_collides?(this_name, that_name)
       case @parser.version
       when 18
@@ -1307,6 +1512,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
     #
@@ -1655,6 +1886,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
     #

data/lib/parser/context.rb

@@ -55,5 +55,9 @@ module Parser
     def in_lambda?
       @stack.last == :lambda
     end
+
+    def in_dynamic_block?
+      in_block? || in_lambda?
+    end
   end
 end

data/lib/parser/current.rb

@@ -75,7 +75,7 @@ module Parser
     CurrentRuby = Ruby26
 
   when /^2\.7\./
-    current_version = '2.7.0-dev'
+    current_version = '2.7.0'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby27', current_version
     end
@@ -85,8 +85,8 @@ module Parser
 
   else # :nocov:
     # Keep this in sync with released Ruby.
-    warn_syntax_deviation 'parser/ruby26', '2.6.x'
-    require 'parser/ruby26'
-    CurrentRuby = Ruby26
+    warn_syntax_deviation 'parser/ruby27', '2.7.x'
+    require 'parser/ruby27'
+    CurrentRuby = Ruby27
   end
 end