parser 2.7.0.5 → 2.7.1.4

data/lib/parser/rubymotion.y

@@ -1018,11 +1018,15 @@ rule
                       result      = @builder.block(val[0],
                                       begin_t, args, body, end_t)
                     }
-                | tLAMBDA lambda
+                | tLAMBDA
+                    {
+                      @context.push(:lambda)
+                    }
+                  lambda
                     {
                       lambda_call = @builder.call_lambda(val[0])
 
-                      args, (begin_t, body, end_t) = val[1]
+                      args, (begin_t, body, end_t) = val[2]
                       result      = @builder.block(lambda_call,
                                       begin_t, args, body, end_t)
                     }
@@ -1136,6 +1140,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @context.push(:module)
                     }
                     bodystmt kEND
                     {
@@ -1148,6 +1153,7 @@ rule
 
                       @lexer.pop_cmdarg
                       @static_env.unextend
+                      @context.pop
                     }
                 | kDEF fname
                     {
@@ -1429,9 +1435,13 @@ rule
           lambda:   {
                       @static_env.extend_dynamic
                     }
-                  f_larglist lambda_body
+                  f_larglist
+                    {
+                      @context.pop
+                    }
+                  lambda_body
                     {
-                      result = [ val[1], val[2] ]
+                      result = [ val[1], val[3] ]
 
                       @static_env.unextend
                     }

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 forward_arg].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

@@ -13,7 +13,7 @@ module Parser
     #        ^^
     #
     # @!attribute [r] source_buffer
-    #  @return [Parser::Diagnostic::Engine]
+    #  @return [Parser::Source::Buffer]
     #
     # @!attribute [r] begin_pos
     #  @return [Integer] index of the first character in the range
@@ -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,71 @@ 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.
+      # This action is atomic in that it won't change the receiver
+      # unless it succeeds.
+      #
+      # @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
+
+      ##
+      # For special cases where one needs to merge a rewriter attached to a different source_buffer
+      # or that needs to be offset. Policies of the receiver are used.
+      #
+      # @param [TreeRewriter] rewriter from different source_buffer
+      # @param [Integer] offset
+      # @return [Rewriter] self
+      # @raise [IndexError] if action ranges (once offset) don't fit the current buffer
+      #
+      def import!(foreign_rewriter, offset: 0)
+        return self if foreign_rewriter.empty?
+
+        contracted = foreign_rewriter.action_root.contract
+        merge_effective_range = ::Parser::Source::Range.new(
+          @source_buffer,
+          contracted.range.begin_pos + offset,
+          contracted.range.end_pos + offset,
+        )
+        check_range_validity(merge_effective_range)
+
+        merge_with = contracted.moved(@source_buffer, offset)
+
+        @action_root = @action_root.combine(merge_with)
+        self
+      end
+
       ##
       # Replaces the code of the source range `range` with `content`.
       #
@@ -185,28 +250,62 @@ 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
+        chunks << source[last_end...source.length]
+        chunks.join
+      end
 
-        source
+      ##
+      # Returns a representation of the rewriter as an ordered list of replacements.
+      #
+      #     rewriter.as_replacements # => [ [1...1, '('],
+      #                                     [2...4, 'foo'],
+      #                                     [5...6, ''],
+      #                                     [6...6, '!'],
+      #                                     [10...10, ')'],
+      #                                   ]
+      #
+      # This representation is sufficient to recreate the result of `process` but it is
+      # not sufficient to recreate completely the rewriter for further merging/actions.
+      # See `as_nested_actions`
+      #
+      # @return [Array<Range, String>] an ordered list of pairs of range & replacement
+      #
+      def as_replacements
+        @action_root.ordered_replacements
+      end
+
+      ##
+      # Returns a representation of the rewriter as nested insertions (:wrap) and replacements.
+      #
+      #     rewriter.as_actions # =>[ [:wrap, 1...10, '(', ')'],
+      #                               [:wrap, 2...6, '', '!'],  # aka "insert_after"
+      #                               [:replace, 2...4, 'foo'],
+      #                               [:replace, 5...6, ''],  # aka "removal"
+      #                             ],
+      #
+      # Contrary to `as_replacements`, this representation is sufficient to recreate exactly
+      # the rewriter.
+      #
+      # @return [Array<(Symbol, Range, String{, String})>]
+      #
+      def as_nested_actions
+        @action_root.nested_actions
       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 +355,10 @@ module Parser
 
       extend Deprecation
 
+      protected
+
+      attr_reader :action_root
+
       private
 
       ACTIONS = %i[accept warn raise].freeze
@@ -273,7 +376,7 @@ module Parser
 
       def check_range_validity(range)
         if range.begin_pos < 0 || range.end_pos > @source_buffer.source.size
-          raise IndexError, "The range #{range} is outside the bounds of the source"
+          raise IndexError, "The range #{range.to_range} is outside the bounds of the source"
         end
         range
       end

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,30 +25,77 @@ 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
 
+      def nested_actions
+        actions = []
+        actions << [:wrap, @range, @insert_before, @insert_after] if !@insert_before.empty? ||
+                                                                     !@insert_after.empty?
+        actions << [:replace, @range, @replacement] if @replacement
+        actions.concat(@children.flat_map(&:nested_actions))
+      end
+
       def insertion?
         !insert_before.empty? || !insert_after.empty? || (replacement && !replacement.empty?)
       end
 
+      ##
+      # A root action has its range set to the whole source range, even
+      # though it typically do not act on that range.
+      # This method returns the action as if it was a child action with
+      # its range contracted.
+      # @return [Action]
+      def contract
+        raise 'Empty actions can not be contracted' if empty?
+        return self if insertion?
+        range = @range.with(
+          begin_pos: children.first.range.begin_pos,
+          end_pos: children.last.range.end_pos,
+        )
+        with(range: range)
+      end
+
+      ##
+      # @return [Action] that has been moved to the given source_buffer and with the given offset
+      # No check is done on validity of resulting range.
+      def moved(source_buffer, offset)
+        moved_range = ::Parser::Source::Range.new(
+          source_buffer,
+          @range.begin_pos + offset,
+          @range.end_pos + offset
+        )
+        with(
+          range: moved_range,
+          children: children.map { |child| child.moved(source_buffer, offset) }
+        )
+      end
+
       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 +108,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 +139,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 +218,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)