parser 2.6.0.0 → 3.1.0.0

data/lib/parser/context.rb

@@ -5,47 +5,45 @@ module Parser
   #
   # Supported states:
   # + :class - in the class body (class A; end)
+  # + :module - in the module body (module M; end)
   # + :sclass - in the singleton class body (class << obj; end)
   # + :def - in the method body (def m; end)
   # + :defs - in the singleton method body (def self.m; end)
+  # + :def_open_args - in the arglist of the method definition
+  #                    keep in mind that it's set **only** after reducing the first argument,
+  #                    if you need to handle the first argument check `lex_state == expr_fname`
   # + :block - in the block body (tap {})
   # + :lambda - in the lambda body (-> {})
   #
   class Context
-    attr_reader :stack
+    FLAGS = %i[
+      in_defined
+      in_kwarg
+      in_argdef
+      in_def
+      in_class
+      in_block
+      in_lambda
+    ]
 
     def initialize
-      @stack = []
-      freeze
-    end
-
-    def push(state)
-      @stack << state
-    end
-
-    def pop
-      @stack.pop
+      reset
     end
 
     def reset
-      @stack.clear
-    end
-
-    def in_class?
-      @stack.last == :class
-    end
-
-    def indirectly_in_def?
-      @stack.include?(:def) || @stack.include?(:defs)
+      @in_defined = false
+      @in_kwarg = false
+      @in_argdef = false
+      @in_def = false
+      @in_class = false
+      @in_block = false
+      @in_lambda = false
     end
 
-    def class_definition_allowed?
-      def_index = stack.rindex { |item| [:def, :defs].include?(item) }
-      sclass_index = stack.rindex(:sclass)
+    attr_accessor(*FLAGS)
 
-      def_index.nil? || (!sclass_index.nil? && sclass_index > def_index)
+    def in_dynamic_block?
+      in_block || in_lambda
     end
-    alias module_definition_allowed? class_definition_allowed?
-    alias dynamic_const_definition_allowed? class_definition_allowed?
   end
 end

data/lib/parser/current.rb

@@ -3,9 +3,9 @@
 module Parser
   class << self
     def warn_syntax_deviation(feature, version)
-      warn "warning: parser/current is loading #{feature}, which recognizes"
-      warn "warning: #{version}-compliant syntax, but you are running #{RUBY_VERSION}."
-      warn "warning: please see https://github.com/whitequark/parser#compatibility-with-ruby-mri."
+      warn "warning: parser/current is loading #{feature}, which recognizes" \
+        "#{version}-compliant syntax, but you are running #{RUBY_VERSION}.\n" \
+        "Please see https://github.com/whitequark/parser#compatibility-with-ruby-mri."
     end
     private :warn_syntax_deviation
   end
@@ -48,7 +48,7 @@ module Parser
     CurrentRuby = Ruby23
 
   when /^2\.4\./
-    current_version = '2.4.5'
+    current_version = '2.4.10'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby24', current_version
     end
@@ -57,7 +57,7 @@ module Parser
     CurrentRuby = Ruby24
 
   when /^2\.5\./
-    current_version = '2.5.3'
+    current_version = '2.5.9'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby25', current_version
     end
@@ -66,7 +66,7 @@ module Parser
     CurrentRuby = Ruby25
 
   when /^2\.6\./
-    current_version = '2.6.0'
+    current_version = '2.6.9'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby26', current_version
     end
@@ -74,10 +74,37 @@ module Parser
     require 'parser/ruby26'
     CurrentRuby = Ruby26
 
+  when /^2\.7\./
+    current_version = '2.7.5'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby27', current_version
+    end
+
+    require 'parser/ruby27'
+    CurrentRuby = Ruby27
+
+  when /^3\.0\./
+    current_version = '3.0.3'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby30', current_version
+    end
+
+    require 'parser/ruby30'
+    CurrentRuby = Ruby30
+
+  when /^3\.1\./
+    current_version = '3.1.0'
+    if RUBY_VERSION != current_version
+      warn_syntax_deviation 'parser/ruby31', current_version
+    end
+
+    require 'parser/ruby31'
+    CurrentRuby = Ruby31
+
   else # :nocov:
     # Keep this in sync with released Ruby.
-    warn_syntax_deviation 'parser/ruby25', '2.5.x'
-    require 'parser/ruby25'
-    CurrentRuby = Ruby25
+    warn_syntax_deviation 'parser/ruby31', '3.1.x'
+    require 'parser/ruby31'
+    CurrentRuby = Ruby31
   end
 end

data/lib/parser/current_arg_stack.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Parser
+  # Stack that holds names of current arguments,
+  # i.e. while parsing
+  #   def m1(a = (def m2(b = def m3(c = 1); end); end)); end
+  #                                   ^
+  # stack is [:a, :b, :c]
+  #
+  # Emulates `p->cur_arg` in MRI's parse.y
+  #
+  # @api private
+  #
+  class CurrentArgStack
+    attr_reader :stack
+
+    def initialize
+      @stack = []
+      freeze
+    end
+
+    def empty?
+      @stack.size == 0
+    end
+
+    def push(value)
+      @stack << value
+    end
+
+    def set(value)
+      @stack[@stack.length - 1] = value
+    end
+
+    def pop
+      @stack.pop
+    end
+
+    def reset
+      @stack.clear
+    end
+
+    def top
+      @stack.last
+    end
+  end
+end

data/lib/parser/diagnostic/engine.rb

@@ -7,8 +7,7 @@ module Parser
   # diagnostics by delegating them to registered consumers.
   #
   # @example
-  #  buffer      = Parser::Source::Buffer.new(__FILE__)
-  #  buffer.code = 'foobar'
+  #  buffer      = Parser::Source::Buffer.new(__FILE__, source: 'foobar')
   #
   #  consumer = lambda do |diagnostic|
   #    puts diagnostic.message

data/lib/parser/diagnostic.rb

@@ -67,7 +67,7 @@ module Parser
     # @return [String] the rendered message.
     #
     def message
-      MESSAGES[@reason] % @arguments
+      Messages.compile(@reason, @arguments)
     end
 
     ##

data/lib/parser/lexer/dedenter.rb

@@ -3,72 +3,81 @@
 module Parser
 
   class Lexer::Dedenter
+    # Tab (\t) counts as 8 spaces
+    TAB_WIDTH = 8
+
     def initialize(dedent_level)
       @dedent_level = dedent_level
       @at_line_begin = true
       @indent_level  = 0
     end
 
+    # For a heredoc like
+    #   <<-HERE
+    #     a
+    #     b
+    #   HERE
+    # this method gets called with "  a\n" and "  b\n"
+    #
+    # However, the following heredoc:
+    #
+    #   <<-HERE
+    #     a\
+    #     b
+    #   HERE
+    # calls this method only once with a string "  a\\\n  b\n"
+    #
+    # This is important because technically it's a single line,
+    # but it has to be concatenated __after__ dedenting.
+    #
+    # It has no effect for non-squiggly heredocs, i.e. it simply removes "\\\n"
+    # Of course, lexer could do it but once again: it's all because of dedenting.
+    #
     def dedent(string)
-      space_begin = space_end = offset = 0
-      last_index  = string.length - 1
-      escape = false
-      _at_line_begin = nil
+      original_encoding = string.encoding
+      # Prevent the following error when processing binary encoded source.
+      # "\xC0".split # => ArgumentError (invalid byte sequence in UTF-8)
+      lines = string.force_encoding(Encoding::BINARY).split("\\\n")
+      if lines.length == 1
+        # If the line continuation sequence was found but there is no second
+        # line, it was not really a line continuation and must be ignored.
+        lines = [string.force_encoding(original_encoding)]
+      else
+        lines.map! {|s| s.force_encoding(original_encoding) }
+      end
 
-      string.chars.each_with_index do |char, index|
-        if char == '\\'
-          # entering escape mode
-          escape = true
-          string.slice!(index - offset)
-          offset += 1
-          _at_line_begin = @at_line_begin
-          @at_line_begin = false
-        elsif escape
-          if char == ?\n
-            # trimming \n, starting a new line
-            string.slice!(index - offset)
-            offset += 1
-            @at_line_begin = true
-            space_begin = space_end = index - offset
-            @indent_level = 0
-          elsif char == ?n
-            # replacing \\n to \n
-            string.slice!(index - offset)
-            string.insert(index - offset, ?\n)
-          else
-            # exiting escape mode as it's not an escape sequence
-            @at_line_begin = _at_line_begin
-            escape = false
-            redo
-          end
-          escape = false
-        elsif @at_line_begin
-          if char == ?\n || @indent_level >= @dedent_level
-            string.slice!(space_begin...space_end)
-            offset += space_end - space_begin
-            @at_line_begin = false
-          end
+      if @at_line_begin
+        lines_to_dedent = lines
+      else
+        _first, *lines_to_dedent = lines
+      end
+
+      lines_to_dedent.each do |line|
+        left_to_remove = @dedent_level
+        remove = 0
 
+        line.each_char do |char|
+          break if left_to_remove <= 0
           case char
           when ?\s
-            @indent_level += 1
-            space_end += 1
+            remove += 1
+            left_to_remove -= 1
           when ?\t
-            @indent_level += 8 - @indent_level % 8
-            space_end += 1
+            break if TAB_WIDTH * (remove / TAB_WIDTH + 1) > @dedent_level
+            remove += 1
+            left_to_remove -= TAB_WIDTH
+          else
+            # no more spaces or tabs
+            break
           end
-        elsif char == ?\n && index == last_index
-          @at_line_begin = true
-          @indent_level  = 0
-          space_begin = space_end = index - offset + 1
         end
-      end
 
-      if @at_line_begin
-        string.slice!(space_begin..space_end)
+        line.slice!(0, remove)
       end
 
-      nil
+      string.replace(lines.join)
+
+      @at_line_begin = string.end_with?("\n")
     end
 
     def interrupt

data/lib/parser/lexer/explanation.rb

@@ -18,7 +18,7 @@ module Parser
     def advance
       type, (val, range) = advance_before_explanation
 
-      more = "(in-kwarg)" if @in_kwarg
+      more = "(in-kwarg)" if @context.in_kwarg
 
       puts decorate(range,
                     Color.green("#{type} #{val.inspect}"),