parser 2.7.0.4 → 2.7.1.3

data/lib/parser/runner.rb

@@ -14,9 +14,8 @@ module Parser
     end
 
     def initialize
-      Parser::Builders::Default.modernize
-
       @option_parser = OptionParser.new { |opts| setup_option_parsing(opts) }
+      @legacy = {}
       @parser_class  = nil
       @parser        = nil
       @files         = []
@@ -30,6 +29,7 @@ module Parser
 
     def execute(options)
       parse_options(options)
+      setup_builder_default
       prepare_parser
 
       process_all_input
@@ -37,6 +37,8 @@ module Parser
 
     private
 
+    LEGACY_MODES = %i[lambda procarg0 encoding index arg_inside_procarg0].freeze
+
     def runner_name
       raise NotImplementedError, "implement #{self.class}##{__callee__}"
     end
@@ -111,6 +113,11 @@ module Parser
         @parser_class = Parser::Ruby27
       end
 
+      opts.on '--28', 'Parse as Ruby 2.8 would' do
+        require 'parser/ruby28'
+        @parser_class = Parser::Ruby28
+      end
+
       opts.on '--mac', 'Parse as MacRuby 0.12 would' do
         require 'parser/macruby'
         @parser_class = Parser::MacRuby
@@ -121,6 +128,17 @@ module Parser
         @parser_class = Parser::RubyMotion
       end
 
+      opts.on '--legacy', "Parse with all legacy modes" do
+        @legacy = Hash.new(true)
+      end
+
+      LEGACY_MODES.each do |mode|
+        opt_name = "--legacy-#{mode.to_s.gsub('_', '-')}"
+        opts.on opt_name, "Parse with legacy mode for emit_#{mode}" do
+          @legacy[mode] = true
+        end
+      end
+
       opts.on '-w', '--warnings', 'Enable warnings' do |w|
         @warnings = w
       end
@@ -159,6 +177,12 @@ module Parser
       end
     end
 
+    def setup_builder_default
+      LEGACY_MODES.each do |mode|
+        Parser::Builders::Default.send(:"emit_#{mode}=", !@legacy[mode])
+      end
+    end
+
     def prepare_parser
       @parser = @parser_class.new
 

data/lib/parser/runner/ruby_rewrite.rb

@@ -55,8 +55,8 @@ module Parser
         new_source = rewriter.rewrite(buffer, ast)
 
         new_buffer = Source::Buffer.new(initial_buffer.name +
-                                    '|after ' + rewriter_class.name)
-        new_buffer.source = new_source
+                                    '|after ' + rewriter_class.name,
+                                    source: new_source)
 
         @parser.reset
         new_ast = @parser.parse(new_buffer)

data/lib/parser/source/buffer.rb

@@ -102,7 +102,7 @@ module Parser
         end
       end
 
-      def initialize(name, first_line = 1)
+      def initialize(name, first_line = 1, source: nil)
         @name        = name.to_s
         @source      = nil
         @first_line  = first_line
@@ -116,6 +116,8 @@ module Parser
         # Cache for fast lookup
         @line_for_position   = {}
         @column_for_position = {}
+
+        self.source = source if source
       end
 
       ##

data/lib/parser/source/comment/associator.rb

@@ -107,6 +107,19 @@ module Parser
 
       private
 
+      POSTFIX_TYPES = Set[:if, :while, :while_post, :until, :until_post].freeze
+      def children_in_source_order(node)
+        if POSTFIX_TYPES.include?(node.type)
+          # All these types have either nodes with expressions, or `nil`
+          # so a compact will do, but they need to be sorted.
+          node.children.compact.sort_by { |child| child.loc.expression.begin_pos }
+        else
+          node.children.select do |child|
+            child.is_a?(AST::Node) && child.loc && child.loc.expression
+          end
+        end
+      end
+
       def do_associate
         @mapping     = Hash.new { |h, k| h[k] = [] }
         @comment_num = -1
@@ -131,10 +144,7 @@ module Parser
         node_loc = node.location
         if @current_comment.location.line <= node_loc.last_line ||
            node_loc.is_a?(Map::Heredoc)
-          node.children.each do |child|
-            next unless child.is_a?(AST::Node) && child.loc && child.loc.expression
-            visit(child)
-          end
+          children_in_source_order(node).each { |child| visit(child) }
 
           process_trailing_comments(node)
         end

data/lib/parser/source/map/endless_definition.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    class Map::EndlessDefinition < Map
+      attr_reader :keyword
+      attr_reader :operator
+      attr_reader :name
+      attr_reader :assignment
+
+      def initialize(keyword_l, operator_l, name_l, assignment_l, body_l)
+        @keyword  = keyword_l
+        @operator = operator_l
+        @name     = name_l
+        @assignment = assignment_l
+
+        super(@keyword.join(body_l))
+      end
+    end
+
+  end
+end

data/lib/parser/source/range.rb

@@ -149,6 +149,13 @@ module Parser
         (@begin_pos...@end_pos).to_a
       end
 
+      ##
+      # @return [Range] a Ruby range with the same `begin_pos` and `end_pos`
+      #
+      def to_range
+        self.begin_pos...self.end_pos
+      end
+
       ##
       # Composes a GNU/Clang-style string representation of the beginning of this
       # range.
@@ -298,6 +305,15 @@ module Parser
         (@end_pos <=> other.end_pos)
       end
 
+      alias_method :eql?, :==
+
+      ##
+      # Support for Ranges be used in as Hash indices and in Sets.
+      #
+      def hash
+        [@source_buffer, @begin_pos, @end_pos].hash
+      end
+
       ##
       # @return [String] a human-readable representation of this range.
       #

data/lib/parser/source/tree_rewriter.rb

@@ -117,6 +117,43 @@ module Parser
         @action_root = TreeRewriter::Action.new(all_encompassing_range, @enforcer)
       end
 
+      ##
+      # Returns true iff no (non trivial) update has been recorded
+      #
+      # @return [Boolean]
+      #
+      def empty?
+        @action_root.empty?
+      end
+
+      ##
+      # Merges the updates of argument with the receiver.
+      # Policies of the receiver are used.
+      #
+      # @param [Rewriter] with
+      # @return [Rewriter] self
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def merge!(with)
+        raise 'TreeRewriter are not for the same source_buffer' unless
+          source_buffer == with.source_buffer
+
+        @action_root = @action_root.combine(with.action_root)
+        self
+      end
+
+      ##
+      # Returns a new rewriter that consists of the updates of the received
+      # and the given argument. Policies of the receiver are used.
+      #
+      # @param [Rewriter] with
+      # @return [Rewriter] merge of receiver and argument
+      # @raise [ClobberingError] when clobbering is detected
+      #
+      def merge(with)
+        dup.merge!(with)
+      end
+
       ##
       # Replaces the code of the source range `range` with `content`.
       #
@@ -185,28 +222,24 @@ module Parser
       # @return [String]
       #
       def process
-        source     = @source_buffer.source.dup
-        adjustment = 0
+        source     = @source_buffer.source
 
+        chunks = []
+        last_end = 0
         @action_root.ordered_replacements.each do |range, replacement|
-          begin_pos = range.begin_pos + adjustment
-          end_pos   = begin_pos + range.length
-
-          source[begin_pos...end_pos] = replacement
-
-          adjustment += replacement.length - range.length
+          chunks << source[last_end...range.begin_pos] << replacement
+          last_end = range.end_pos
         end
-
-        source
+        chunks << source[last_end...source.length]
+        chunks.join
       end
 
       ##
       # Provides a protected block where a sequence of multiple rewrite actions
       # are handled atomically. If any of the actions failed by clobbering,
-      # all the actions are rolled back.
+      # all the actions are rolled back. Transactions can be nested.
       #
       # @raise [RuntimeError] when no block is passed
-      # @raise [RuntimeError] when already in a transaction
       #
       def transaction
         unless block_given?
@@ -256,6 +289,10 @@ module Parser
 
       extend Deprecation
 
+      protected
+
+      attr_reader :action_root
+
       private
 
       ACTIONS = %i[accept warn raise].freeze

data/lib/parser/source/tree_rewriter/action.rb

@@ -7,7 +7,7 @@ module Parser
     #
     # Actions are arranged in a tree and get combined so that:
     #   children are strictly contained by their parent
-    #   sibblings all disjoint from one another
+    #   sibblings all disjoint from one another and ordered
     #   only actions with replacement==nil may have children
     #
     class TreeRewriter::Action
@@ -25,17 +25,23 @@ module Parser
         freeze
       end
 
-      # Assumes action.children.empty?
       def combine(action)
-        return self unless action.insertion? || action.replacement # Ignore empty action
+        return self if action.empty? # Ignore empty action
         do_combine(action)
       end
 
+      def empty?
+        @insert_before.empty? &&
+          @insert_after.empty? &&
+          @children.empty? &&
+          (@replacement == nil || (@replacement.empty? && @range.empty?))
+      end
+
       def ordered_replacements
         reps = []
         reps << [@range.begin, @insert_before] unless @insert_before.empty?
         reps << [@range, @replacement] if @replacement
-        reps.concat(@children.sort_by(&:range).flat_map(&:ordered_replacements))
+        reps.concat(@children.flat_map(&:ordered_replacements))
         reps << [@range.end, @insert_after] unless @insert_after.empty?
         reps
       end
@@ -46,9 +52,11 @@ module Parser
 
       protected
 
-      def with(range: @range, children: @children, insert_before: @insert_before, replacement: @replacement, insert_after: @insert_after)
+      attr_reader :children
+
+      def with(range: @range, enforcer: @enforcer, children: @children, insert_before: @insert_before, replacement: @replacement, insert_after: @insert_after)
         children = swallow(children) if replacement
-        self.class.new(range, @enforcer, children: children, insert_before: insert_before, replacement: replacement, insert_after: insert_after)
+        self.class.new(range, enforcer, children: children, insert_before: insert_before, replacement: replacement, insert_after: insert_after)
       end
 
       # Assumes range.contains?(action.range) && action.children.empty?
@@ -61,19 +69,27 @@ module Parser
       end
 
       def place_in_hierarchy(action)
-        family = @children.group_by { |child| child.relationship_with(action) }
+        family = analyse_hierarchy(action)
 
         if family[:fusible]
-          fuse_deletions(action, family[:fusible], [*family[:sibbling], *family[:child]])
+          fuse_deletions(action, family[:fusible], [*family[:sibbling_left], *family[:child], *family[:sibbling_right]])
         else
           extra_sibbling = if family[:parent]  # action should be a descendant of one of the children
-            family[:parent][0].do_combine(action)
+            family[:parent].do_combine(action)
           elsif family[:child]                 # or it should become the parent of some of the children,
-            action.with(children: family[:child])
+            action.with(children: family[:child], enforcer: @enforcer)
+              .combine_children(action.children)
           else                                 # or else it should become an additional child
             action
           end
-          with(children: [*family[:sibbling], extra_sibbling])
+          with(children: [*family[:sibbling_left], extra_sibbling, *family[:sibbling_right]])
+        end
+      end
+
+      # Assumes `more_children` all contained within `@range`
+      def combine_children(more_children)
+        more_children.inject(self) do |parent, new_child|
+          parent.place_in_hierarchy(new_child)
         end
       end
 
@@ -84,22 +100,76 @@ module Parser
         without_fusible.do_combine(fused_deletion)
       end
 
-      # Returns what relationship self should have with `action`; either of
-      #   :sibbling, :parent, :child, :fusible or raises a CloberingError
-      # In case of equal range, returns :parent
-      def relationship_with(action)
-        if action.range == @range || @range.contains?(action.range)
-          :parent
-        elsif @range.contained?(action.range)
-          :child
-        elsif @range.disjoint?(action.range)
-          :sibbling
-        elsif !action.insertion? && !insertion?
-          @enforcer.call(:crossing_deletions) { {range: action.range, conflict: @range} }
-          :fusible
+      # Similar to @children.bsearch_index || size
+      # except allows for a starting point
+      # and `bsearch_index` is only Ruby 2.3+
+      def bsearch_child_index(from = 0)
+        size = @children.size
+        (from...size).bsearch { |i| yield @children[i] } || size
+      end
+
+      # Returns the children in a hierarchy with respect to `action`:
+      #   :sibbling_left, sibbling_right (for those that are disjoint from `action`)
+      #   :parent (in case one of our children contains `action`)
+      #   :child (in case `action` strictly contains some of our children)
+      #   :fusible (in case `action` overlaps some children but they can be fused in one deletion)
+      #   or raises a `CloberingError`
+      # In case a child has equal range to `action`, it is returned as `:parent`
+      # Reminder: an empty range 1...1 is considered disjoint from 1...10
+      def analyse_hierarchy(action)
+        r = action.range
+        # left_index is the index of the first child that isn't completely to the left of action
+        left_index = bsearch_child_index { |child| child.range.end_pos > r.begin_pos }
+        # right_index is the index of the first child that is completely on the right of action
+        start = left_index == 0 ? 0 : left_index - 1  # See "corner case" below for reason of -1
+        right_index = bsearch_child_index(start) { |child| child.range.begin_pos >= r.end_pos }
+        center = right_index - left_index
+        case center
+        when 0
+          # All children are disjoint from action, nothing else to do
+        when -1
+          # Corner case: if a child has empty range == action's range
+          # then it will appear to be both disjoint and to the left of action,
+          # as well as disjoint and to the right of action.
+          # Since ranges are equal, we return it as parent
+          left_index -= 1  # Fix indices, as otherwise this child would be
+          right_index += 1 # considered as a sibbling (both left and right!)
+          parent = @children[left_index]
         else
-          @enforcer.call(:crossing_insertions) { {range: action.range, conflict: @range} }
+          overlap_left = @children[left_index].range.begin_pos <=> r.begin_pos
+          overlap_right = @children[right_index-1].range.end_pos <=> r.end_pos
+
+          # For one child to be the parent of action, we must have:
+          if center == 1 && overlap_left <= 0 && overlap_right >= 0
+            parent = @children[left_index]
+          else
+            # Otherwise consider all non disjoint elements (center) to be contained...
+            contained = @children[left_index...right_index]
+            fusible = check_fusible(action,
+              (contained.shift if overlap_left < 0),  # ... but check first and last one
+              (contained.pop if overlap_right > 0)    # ... for overlaps
+            )
+          end
         end
+
+        {
+          parent: parent,
+          sibbling_left: @children[0...left_index],
+          sibbling_right: @children[right_index...@children.size],
+          fusible: fusible,
+          child: contained,
+        }
+      end
+
+      # @param [Array(Action | nil)] fusible
+      def check_fusible(action, *fusible)
+        fusible.compact!
+        return if fusible.empty?
+        fusible.each do |child|
+          kind = action.insertion? || child.insertion? ? :crossing_insertions : :crossing_deletions
+          @enforcer.call(kind) { {range: action.range, conflict: child.range} }
+        end
+        fusible
       end
 
       # Assumes action.range == range && action.children.empty?
@@ -109,7 +179,7 @@ module Parser
           insert_before: "#{action.insert_before}#{insert_before}",
           replacement: action.replacement || @replacement,
           insert_after: "#{insert_after}#{action.insert_after}",
-        )
+        ).combine_children(action.children)
       end
 
       def call_enforcer_for_merge(action)