parser 2.6.0.0 → 3.1.0.0

data/lib/parser/max_numparam_stack.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Parser
+
+  # Holds p->max_numparam from parse.y
+  #
+  # @api private
+  class MaxNumparamStack
+    attr_reader :stack
+
+    ORDINARY_PARAMS = -1
+
+    def initialize
+      @stack = []
+    end
+
+    def empty?
+      @stack.size == 0
+    end
+
+    def has_ordinary_params!
+      set(ORDINARY_PARAMS)
+    end
+
+    def has_ordinary_params?
+      top == ORDINARY_PARAMS
+    end
+
+    def has_numparams?
+      top && top > 0
+    end
+
+    def register(numparam)
+      set( [top, numparam].max )
+    end
+
+    def top
+      @stack.last[:value]
+    end
+
+    def push(static:)
+      @stack.push(value: 0, static: static)
+    end
+
+    def pop
+      @stack.pop[:value]
+    end
+
+    private
+
+    def set(value)
+      @stack.last[:value] = value
+    end
+  end
+
+end

data/lib/parser/messages.rb

@@ -10,60 +10,79 @@ module Parser
   #
   MESSAGES = {
     # Lexer errors
-    :unicode_point_too_large => 'invalid Unicode codepoint (too large)',
-    :invalid_escape          => 'invalid escape character syntax',
-    :incomplete_escape       => 'incomplete character syntax',
-    :invalid_hex_escape      => 'invalid hex escape',
-    :invalid_unicode_escape  => 'invalid Unicode escape',
-    :unterminated_unicode    => 'unterminated Unicode escape',
-    :escape_eof              => 'escape sequence meets end of file',
-    :string_eof              => 'unterminated string meets end of file',
-    :regexp_options          => 'unknown regexp options: %{options}',
-    :cvar_name               => "`%{name}' is not allowed as a class variable name",
-    :ivar_name               => "`%{name}' is not allowed as an instance variable name",
-    :trailing_in_number      => "trailing `%{character}' in number",
-    :empty_numeric           => 'numeric literal without digits',
-    :invalid_octal           => 'invalid octal digit',
-    :no_dot_digit_literal    => 'no .<digit> floating literal anymore; put 0 before dot',
-    :bare_backslash          => 'bare backslash only allowed before newline',
-    :unexpected              => "unexpected `%{character}'",
-    :embedded_document       => 'embedded document meets end of file (and they embark on a romantic journey)',
-    :heredoc_id_has_newline  => 'here document identifier across newlines, never match',
-    :heredoc_id_ends_with_nl => 'here document identifier ends with a newline',
+    :unicode_point_too_large  => 'invalid Unicode codepoint (too large)',
+    :invalid_escape           => 'invalid escape character syntax',
+    :incomplete_escape        => 'incomplete character syntax',
+    :invalid_hex_escape       => 'invalid hex escape',
+    :invalid_unicode_escape   => 'invalid Unicode escape',
+    :unterminated_unicode     => 'unterminated Unicode escape',
+    :escape_eof               => 'escape sequence meets end of file',
+    :string_eof               => 'unterminated string meets end of file',
+    :regexp_options           => 'unknown regexp options: %{options}',
+    :cvar_name                => "`%{name}' is not allowed as a class variable name",
+    :ivar_name                => "`%{name}' is not allowed as an instance variable name",
+    :trailing_in_number       => "trailing `%{character}' in number",
+    :empty_numeric            => 'numeric literal without digits',
+    :invalid_octal            => 'invalid octal digit',
+    :no_dot_digit_literal     => 'no .<digit> floating literal anymore; put 0 before dot',
+    :bare_backslash           => 'bare backslash only allowed before newline',
+    :unexpected               => "unexpected `%{character}'",
+    :embedded_document        => 'embedded document meets end of file (and they embark on a romantic journey)',
+    :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',
 
     # 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_regexp        => "ambiguity between regexp and two divisions: wrap regexp in parentheses or add a space after `/' 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',
+    :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}',
+    :reserved_for_numparam        => '%{name} is reserved for numbered parameter',
+    :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}',
+    :endless_setter               => 'setter method cannot be defined in an endless method definition',
+    :invalid_id_to_get            => 'identifier %{identifier} is not valid to get',
+    :forward_arg_after_restarg    => '... after rest argument',
+    :no_anonymous_blockarg        => 'no anonymous block parameter',
 
     # Parser warnings
     :useless_else            => 'else without rescue is useless',
+    :duplicate_hash_key      => 'key is duplicated and overwritten',
 
     # Parser errors that are not Ruby errors
     :invalid_encoding        => 'literal contains escape sequences incompatible with UTF-8',
@@ -81,4 +100,19 @@ module Parser
     :crossing_insertions           => 'the rewriting action on:',
     :crossing_insertions_conflict  => 'is crossing that on:',
   }.freeze
+
+  # @api private
+  module Messages
+    # Formats the message, returns a raw template if there's nothing to interpolate
+    #
+    # Code like `format("", {})` gives a warning, and so this method tries interpolating
+    # only if `arguments` hash is not empty.
+    #
+    # @api private
+    def self.compile(reason, arguments)
+      template = MESSAGES[reason]
+      return template if Hash === arguments && arguments.empty?
+      format(template, arguments)
+    end
+  end
 end

data/lib/parser/meta.rb

@@ -7,7 +7,7 @@ module Parser
     # All node types that parser can produce. Not all parser versions
     # will be able to produce every possible node.
     NODE_TYPES =
-      %w(
+      %i(
         true false nil int float str dstr
         sym dsym xstr regopt regexp array splat
         pair kwsplat hash irange erange self
@@ -18,12 +18,22 @@ module Parser
         match_with_lvasgn match_current_line
         module class sclass def defs undef alias args
         cbase arg optarg restarg blockarg block_pass kwarg kwoptarg
-        kwrestarg send csend super zsuper yield block
+        kwrestarg kwnilarg send csend super zsuper yield block
         and not or if when case while until while_post
         until_post for break next redo return resbody
         kwbegin begin retry preexe postexe iflipflop eflipflop
         shadowarg complex rational __FILE__ __LINE__ __ENCODING__
-      ).map(&:to_sym).to_set.freeze
+        ident lambda indexasgn index procarg0
+        restarg_expr blockarg_expr
+        objc_kwarg objc_restarg objc_varargs
+        numargs numblock forward_args forwarded_args forward_arg
+        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 find_pattern kwargs
+        match_pattern_p match_pattern
+      ).to_set.freeze
 
   end # Meta
 end # Parser