parser 2.7.0.2 → 2.7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb64651ef64daa71d4c55d8ab253c90ce470eaf85f3b0ce98dfe5f171a681c80
-  data.tar.gz: a875a3b5c4a92b7fae3a58c379c300519e7c328641a7cb8d8a65e3f131118eed
+  metadata.gz: fb7c9797808fcd8920ef34ccce6dae7f416d0fe3084a863fa3fec7fa30b086fc
+  data.tar.gz: 828a937688a35e277c7d435197ca2d023458de366a8e94fbaa67bdd6d3a04145
 SHA512:
-  metadata.gz: 8bd9f983ef31671217011a895e07b466f5327578f1dbc2288e5bcd08e367d038e0ee53c35ee1851323c8b04ab20e3fd27c1347a7615c869a99ebcebc8a949baf
-  data.tar.gz: cab52019893fb86e6fe66aaa9391d9d6cd721daac62550f7a0d2303bafbcc6deac349c4366315f8bc4ba15f6309b7ead3f30e3ff8fcd0e15a394c63c86071db7
+  metadata.gz: 679bc103f3d8b2663a1ec2de6c3acac41c90c1d738b40bf4b5ed945b8e3f51e22359caa0789e55009f3bd2c45ac832d00182db9ba9be1f43b18e6fe0e0508278
+  data.tar.gz: b4f4d29766e23ca406644fb578e2134f28a9983d765d4aa45117dcb5a9ee012f27c2b8b65eccf11b7e3818b1543a62cc0483aa510a51352bc2260ad0fd650acd

data/.travis.yml

@@ -2,26 +2,17 @@ dist: trusty
 language: ruby
 matrix:
   include:
-    - name: 2.0.0 / Parser tests
-      rvm: 2.0.0
+    - name: 2.4.10 / Parser tests
+      rvm: 2.4.10
       script: bundle exec rake test_cov
-    - name: 2.2.10 / Parser tests
-      rvm: 2.2.10
+    - name: 2.5.8 / Parser tests
+      rvm: 2.5.8
       script: bundle exec rake test_cov
-    - name: 2.3.8 / Parser tests
-      rvm: 2.3.8
+    - name: 2.6.6 / Parser tests
+      rvm: 2.6.6
       script: bundle exec rake test_cov
-    - name: 2.4.9 / Parser tests
-      rvm: 2.4.9
-      script: bundle exec rake test_cov
-    - name: 2.5.7 / Parser tests
-      rvm: 2.5.7
-      script: bundle exec rake test_cov
-    - name: 2.6.5 / Parser tests
-      rvm: 2.6.5
-      script: bundle exec rake test_cov
-    - name: 2.7.0 / Parser tests
-      rvm: 2.7.0
+    - name: 2.7.1 / Parser tests
+      rvm: 2.7.1
       script: bundle exec rake test_cov
     - name: ruby-head / Parser tests
       rvm: ruby-head
@@ -32,14 +23,14 @@ matrix:
     - name: rbx-2 / Parser tests
       rvm: rbx-2
       script: bundle exec rake test_cov
-    - name: 2.5.7 / Rubocop tests
-      rvm: 2.5.7
+    - name: 2.5.8 / Rubocop tests
+      rvm: 2.5.8
       script: ./ci/run_rubocop_specs
-    - name: 2.6.5 / Rubocop tests
-      rvm: 2.6.5
+    - name: 2.6.6 / Rubocop tests
+      rvm: 2.6.6
       script: ./ci/run_rubocop_specs
-    - name: 2.7.0 / Rubocop tests
-      rvm: 2.7.0
+    - name: 2.7.1 / Rubocop tests
+      rvm: 2.7.1
       script: ./ci/run_rubocop_specs
   allow_failures:
     - rvm: ruby-head

data/CHANGELOG.md

@@ -1,9 +1,41 @@
 Changelog
 =========
 
-Not released (2020-01-08)
+Not released (2020-04-15)
 -------------------------
 
+Features implemented:
+ * Add Source::Range#eql? and hash (#675) (Marc-André Lafortune)
+ * Source::TreeRewriter: Add #merge, #merge! and #empty? (#674) (Marc-André Lafortune)
+
+v2.7.1.0 (2020-04-03)
+---------------------
+
+API modifications:
+ * Bump ruby versions to 2.4.10, 2.5.8, 2.6.6, 2.7.1. (#665) (Ilya Bylich)
+
+Features implemented:
+ * ruby27.y: allow newlines inside braced pattern. (#664) (Ilya Bylich)
+ * ruby27.y: Allow trailing comma in hash pattern (#661) (Koichi ITO)
+
+v2.7.0.5 (2020-03-20)
+---------------------
+
+Features implemented:
+ * ruby27.y: fix array pattern with tail source map (#659) (Vladimir Dementyev)
+
+Bugs fixed:
+ * builder.rb: fix constant_pattern source map (#660) (Vladimir Dementyev)
+
+v2.7.0.4 (2020-03-02)
+---------------------
+
+Bugs fixed:
+ * lexer.rl: allow spaces before comments-before-leading-dot. (#654) (Ilya Bylich)
+
+v2.7.0.2 (2020-01-08)
+---------------------
+
 Bugs fixed:
  * lexer.rl: fix paren_nest for curly braces (#646) (Ilya Bylich)
 

data/README.md

@@ -24,10 +24,11 @@ below for explanation of `emit_*` calls):
 
     require 'parser/current'
     # opt-in to most recent AST format:
-    Parser::Builders::Default.emit_lambda   = true
-    Parser::Builders::Default.emit_procarg0 = true
-    Parser::Builders::Default.emit_encoding = true
-    Parser::Builders::Default.emit_index    = true
+    Parser::Builders::Default.emit_lambda              = true
+    Parser::Builders::Default.emit_procarg0            = true
+    Parser::Builders::Default.emit_encoding            = true
+    Parser::Builders::Default.emit_index               = true
+    Parser::Builders::Default.emit_arg_inside_procarg0 = true
 
 Parse a chunk of code:
 
@@ -234,7 +235,7 @@ Parser implements the MacRuby 0.12 and RubyMotion mid-2015 parsers precisely. Ho
 
 ## Known issues
 
-Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occuring corner cases, this is not done.
+Adding support for the following Ruby MRI features in Parser would needlessly complicate it, and as they all are very specific and rarely occurring corner cases, this is not done.
 
 Parser has been extensively tested; in particular, it parses almost entire [Rubygems][rg] corpus. For every issue, a breakdown of affected gems is offered.
 

data/doc/AST_FORMAT.md

@@ -1870,6 +1870,27 @@ Format:
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
 ~~~
 
+#### With empty else
+
+Empty `else` differs from the missing (or _implicit_) `else` for pattern matching, since
+the latter one raises a `NoMatchingPattern` exception. Thus, we need a way to distinguish this
+two cases in the resulting AST.
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (empty-else))
+"case "str"; in foo; bar; else; end"
+ ~~~~ keyword             ~~~~ else
+                                ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
 ### In clause
 
 Format:
@@ -2047,7 +2068,7 @@ so a single item match with comma gets interpreted as an array.
 (array-pattern-with-tail
   (match-var :foo))
 "in foo,"
-    ~~~ expression
+    ~~~~ expression
 ~~~
 
 ### Matching using hash pattern
@@ -2118,7 +2139,7 @@ Format:
 "in X[^foo bar]"
      ~ begin (const-pattern)
                ~ end (const-pattern)
-     ~~~~~~~~~~~ expression (const-pattern)
+    ~~~~~~~~~~~~ expression (const-pattern)
     ~ name (const-pattern.const)
     ~ expression (const-pattern.const)
 ~~~
@@ -2136,7 +2157,24 @@ Format:
 "in X[foo:, bar:]"
      ~ begin (const-pattern)
                 ~ end (const-pattern)
-     ~~~~~~~~~~~~ expression (const-pattern)
+    ~~~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With array pattern without elements
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern))
+"in X[]"
+     ~ begin (const-pattern)
+      ~ end (const-pattern)
+    ~~~ expression (const-pattern)
     ~ name (const-pattern.const)
     ~ expression (const-pattern.const)
+     ~~ expression (const-pattern.array_pattern)
 ~~~

data/lib/parser/ast/processor.rb

@@ -274,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/builders/default.rb

@@ -1213,6 +1213,7 @@ module Parser
     #
 
     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
@@ -1313,9 +1314,11 @@ module Parser
     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|
+      node_elements = elements.map do |element|
         if element.type == :match_with_trailing_comma
           trailing_comma = true
           element.children.first
@@ -1326,17 +1329,22 @@ module Parser
       end
 
       node_type = trailing_comma ? :array_pattern_with_tail : :array_pattern
-      n(node_type, elements,
+
+      n(node_type, node_elements,
         collection_map(lbrack_t, elements, rbrack_t))
     end
 
-    def match_with_trailing_comma(match)
-      n(:match_with_trailing_comma, [ match ], nil)
+    def match_with_trailing_comma(match, comma_t)
+      n(:match_with_trailing_comma, [ match ], expr_map(match.loc.expression.join(loc(comma_t))))
     end
 
     def const_pattern(const, ldelim_t, pattern, rdelim_t)
       n(:const_pattern, [const, pattern],
-        collection_map(ldelim_t, [pattern], rdelim_t))
+        Source::Map::Collection.new(
+          loc(ldelim_t), loc(rdelim_t),
+          const.loc.expression.join(loc(rdelim_t))
+        )
+      )
     end
 
     def pin(pin_t, var)
@@ -1369,11 +1377,13 @@ module Parser
         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))
-          loc = loc(begin_t).join(loc(end_t))
-          check_duplicate_pattern_key(var_name, loc)
+          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)

data/lib/parser/current.rb

@@ -48,7 +48,7 @@ module Parser
     CurrentRuby = Ruby23
 
   when /^2\.4\./
-    current_version = '2.4.9'
+    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.7'
+    current_version = '2.5.8'
     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.5'
+    current_version = '2.6.6'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby26', current_version
     end
@@ -75,7 +75,7 @@ module Parser
     CurrentRuby = Ruby26
 
   when /^2\.7\./
-    current_version = '2.7.0'
+    current_version = '2.7.1'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby27', current_version
     end

data/lib/parser/lexer.rl

@@ -2473,7 +2473,7 @@ class Parser::Lexer
 
       # Here we use '\n' instead of w_newline to not modify @newline_s
       # and eventually properly emit tNL
-      (w_space_comment '\n')+
+      (c_space* w_space_comment '\n')+
       => {
         if @version < 27
           # Ruby before 2.7 doesn't support comments before leading dot.

data/lib/parser/messages.rb

@@ -70,6 +70,7 @@ module Parser
     :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}',
 

data/lib/parser/meta.rb

@@ -31,6 +31,7 @@ module Parser
         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
       ).map(&:to_sym).to_set.freeze
 
   end # Meta

data/lib/parser/ruby27.y

@@ -1784,7 +1784,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like 1, 2,
                       # must be emitted as `array_pattern_with_tail`
-                      item = @builder.match_with_trailing_comma(val[0])
+                      item = @builder.match_with_trailing_comma(val[0], val[1])
                       result = @builder.array_pattern(nil, [ item ], nil)
                     }
                 | p_expr tCOMMA p_args
@@ -1841,7 +1841,8 @@ opt_block_args_tail:
                     }
                 | p_const tLPAREN2 rparen
                     {
-                      result = @builder.const_pattern(val[0], val[1], nil, val[2])
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
                     }
                 | p_const p_lbracket p_args rbracket
                     {
@@ -1857,7 +1858,8 @@ opt_block_args_tail:
                     }
                 | p_const tLBRACK2 rbracket
                     {
-                      result = @builder.const_pattern(val[0], val[1], nil, val[2])
+                      pattern = @builder.array_pattern(val[1], nil, val[2])
+                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])
                     }
                 | tLBRACK
                     {
@@ -1875,13 +1877,16 @@ opt_block_args_tail:
                 | tLBRACE
                     {
                       @pattern_hash_keys.push
+                      result = @lexer.in_kwarg
+                      @lexer.in_kwarg = false
                     }
-                  p_kwargs tRCURLY
+                  p_kwargs rbrace
                     {
                       @pattern_hash_keys.pop
+                      @lexer.in_kwarg = val[1]
                       result = @builder.hash_pattern(val[0], val[2], val[3])
                     }
-                | tLBRACE tRCURLY
+                | tLBRACE rbrace
                     {
                       result = @builder.hash_pattern(val[0], [], val[1])
                     }
@@ -1932,7 +1937,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like [1, 2,]
                       # must be emitted as `array_pattern_with_tail`
-                      item = @builder.match_with_trailing_comma(val[0])
+                      item = @builder.match_with_trailing_comma(val[0], val[1])
                       result = [ item ]
                     }
                 | p_args_head p_arg tCOMMA
@@ -1940,7 +1945,7 @@ opt_block_args_tail:
                       # array patterns that end with comma
                       # like [1, 2,]
                       # must be emitted as `array_pattern_with_tail`
-                      last_item = @builder.match_with_trailing_comma(val[1])
+                      last_item = @builder.match_with_trailing_comma(val[1], val[2])
                       result = [ *val[0], last_item ]
                     }
 
@@ -1984,6 +1989,10 @@ opt_block_args_tail:
                     {
                       result = val[0]
                     }
+                | p_kwarg tCOMMA
+                    {
+                      result = val[0]
+                    }
                 | p_kwrest
                     {
                       result = val[0]
@@ -2096,6 +2105,11 @@ opt_block_args_tail:
 
        p_var_ref: tCARET tIDENTIFIER
                     {
+                      name = val[1][0]
+                      unless static_env.declared?(name)
+                        diagnostic :error, :undefined_lvar, { :name => name }, val[1]
+                      end
+
                       lvar = @builder.accessible(@builder.ident(val[1]))
                       result = @builder.pin(val[0], lvar)
                     }
@@ -2891,6 +2905,10 @@ keyword_variable: kNIL
                     {
                       result = val[1]
                     }
+          rbrace: opt_nl tRCURLY
+                    {
+                      result = val[1]
+                    }
          trailer:  | tNL | tCOMMA
 
             term: tSEMI

data/lib/parser/source/range.rb

@@ -298,6 +298,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`.
       #
@@ -203,10 +240,9 @@ module Parser
       ##
       # 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 +292,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

@@ -25,12 +25,18 @@ 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?
@@ -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?
@@ -56,11 +64,11 @@ module Parser
         if action.range == @range
           merge(action)
         else
-          place_in_hierachy(action)
+          place_in_hierarchy(action)
         end
       end
 
-      def place_in_hierachy(action)
+      def place_in_hierarchy(action)
         family = @children.group_by { |child| child.relationship_with(action) }
 
         if family[:fusible]
@@ -69,7 +77,8 @@ module Parser
           extra_sibbling = if family[:parent]  # action should be a descendant of one of the children
             family[:parent][0].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
@@ -77,6 +86,13 @@ module Parser
         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
+
       def fuse_deletions(action, fusible, other_sibblings)
         without_fusible = with(children: other_sibblings)
         fused_range = [action, *fusible].map(&:range).inject(:join)
@@ -109,7 +125,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)

data/lib/parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parser
-  VERSION = '2.7.0.2'
+  VERSION = '2.7.1.1'
 end

data/parser.gemspec

@@ -13,6 +13,13 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/whitequark/parser'
   spec.license       = 'MIT'
 
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/whitequark/parser/issues',
+    'changelog_uri' => "https://github.com/whitequark/parser/blob/v#{spec.version}/CHANGELOG.md",
+    'documentation_uri' => "https://www.rubydoc.info/gems/parser/#{spec.version}",
+    'source_code_uri' => "https://github.com/whitequark/parser/tree/v#{spec.version}"
+  }
+
   spec.files         = `git ls-files`.split + %w(
                           lib/parser/lexer.rb
                           lib/parser/ruby18.rb

data/test/test_parser.rb

@@ -7644,12 +7644,26 @@ class TestParser < Minitest::Test
       %q{},
       SINCE_2_7)
 
+    assert_parses(
+      s(:send,
+        s(:send, nil, :a), :foo),
+      %Q{a #\n  #\n.foo\n},
+      %q{},
+      SINCE_2_7)
+
     assert_parses(
       s(:csend,
         s(:send, nil, :a), :foo),
       %Q{a #\n#\n&.foo\n},
       %q{},
       SINCE_2_7)
+
+    assert_parses(
+      s(:csend,
+        s(:send, nil, :a), :foo),
+      %Q{a #\n  #\n&.foo\n},
+      %q{},
+      SINCE_2_7)
   end
 
   def test_comments_before_leading_dot__before_27
@@ -8408,7 +8422,7 @@ class TestParser < Minitest::Test
         nil,
         s(:nil)),
       %q{in x, then nil},
-      %q{   ~ expression (in_pattern.array_pattern_with_tail)}
+      %q{   ~~ expression (in_pattern.array_pattern_with_tail)}
     )
 
     assert_parses_pattern_match(
@@ -8454,7 +8468,7 @@ class TestParser < Minitest::Test
         nil,
         s(:nil)),
       %q{in x, y, then nil},
-      %q{   ~~~~ expression (in_pattern.array_pattern_with_tail)}
+      %q{   ~~~~~ expression (in_pattern.array_pattern_with_tail)}
     )
 
     assert_parses_pattern_match(
@@ -8661,6 +8675,18 @@ class TestParser < Minitest::Test
         |          ~ end (in_pattern.hash_pattern)}
     )
 
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:pair, s(:sym, :a), s(:int, 1))),
+        nil,
+        s(:true)),
+      %q{in { a: 1, } then true},
+      %q{   ~~~~~~~~~ expression (in_pattern.hash_pattern)
+        |   ~ begin (in_pattern.hash_pattern)
+        |           ~ end (in_pattern.hash_pattern)}
+    )
+
     assert_parses_pattern_match(
       s(:in_pattern,
         s(:hash_pattern,
@@ -8732,6 +8758,67 @@ class TestParser < Minitest::Test
       %q{in a: 1, _a:, ** then true},
       %q{   ~~~~~~~~~~~~~ expression (in_pattern.hash_pattern)}
     )
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:pair,
+            s(:sym, :a),
+            s(:int, 1))), nil,
+        s(:false)),
+      %q{
+        in {a: 1
+        }
+          false
+      },
+      %q{}
+    )
+
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:pair,
+            s(:sym, :a),
+            s(:int, 2))), nil,
+        s(:false)),
+      %q{
+        in {a:
+              2}
+          false
+      },
+      %q{}
+    )
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:pair,
+            s(:sym, :a),
+            s(:hash_pattern,
+              s(:match_var, :b))),
+          s(:match_var, :c)), nil,
+        s(:send, nil, :p,
+          s(:lvar, :c))),
+      %q{
+        in a: {b:}, c:
+          p c
+      },
+      %q{}
+    )
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:match_var, :a)), nil,
+        s(:true)),
+      %q{
+        in {a:
+        }
+          true
+      },
+      %q{}
+    )
   end
 
   def test_pattern_matching_hash_with_string_keys
@@ -8839,6 +8926,15 @@ class TestParser < Minitest::Test
     )
   end
 
+  def test_pattern_matching_hash_with_string_interpolation_keys
+    assert_diagnoses(
+      [:error, :pm_interp_in_var_name],
+      %q{case a; in "#{a}": 1; end},
+      %q{           ~~~~~~~ location},
+      SINCE_2_7
+    )
+  end
+
   def test_pattern_matching_keyword_variable
     assert_parses_pattern_match(
       s(:in_pattern,
@@ -8970,7 +9066,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A(1, 2) then true},
-      %q{    ~~~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |         ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -8986,7 +9082,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A(x:) then true},
-      %q{    ~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |       ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -8997,13 +9093,15 @@ class TestParser < Minitest::Test
       s(:in_pattern,
         s(:const_pattern,
           s(:const, nil, :A),
-          nil),
+          s(:array_pattern)),
         nil,
         s(:true)),
       %q{in A() then true},
-      %q{    ~~ expression (in_pattern.const_pattern)
+      %q{   ~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
-        |     ~ end (in_pattern.const_pattern)}
+        |     ~ end (in_pattern.const_pattern)
+        |   ~ expression (in_pattern.const_pattern.const)
+        |    ~~ expression (in_pattern.const_pattern.array_pattern)}
     )
 
     assert_parses_pattern_match(
@@ -9016,7 +9114,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A[1, 2] then true},
-      %q{    ~~~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |         ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -9032,7 +9130,7 @@ class TestParser < Minitest::Test
         nil,
         s(:true)),
       %q{in A[x:] then true},
-      %q{    ~~~~ expression (in_pattern.const_pattern)
+      %q{   ~~~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
         |       ~ end (in_pattern.const_pattern)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -9043,13 +9141,14 @@ class TestParser < Minitest::Test
       s(:in_pattern,
         s(:const_pattern,
           s(:const, nil, :A),
-          nil),
+          s(:array_pattern)),
         nil,
         s(:true)),
       %q{in A[] then true},
-      %q{    ~~ expression (in_pattern.const_pattern)
+      %q{   ~~~ expression (in_pattern.const_pattern)
         |    ~ begin (in_pattern.const_pattern)
-        |     ~ end (in_pattern.const_pattern)}
+        |     ~ end (in_pattern.const_pattern)
+        |    ~~ expression (in_pattern.const_pattern.array_pattern)}
     )
   end
 
@@ -9093,6 +9192,20 @@ class TestParser < Minitest::Test
     )
   end
 
+  def test_pattern_matching_blank_else
+    assert_parses(
+      s(:case_match,
+        s(:int, 1),
+        s(:in_pattern,
+          s(:int, 2), nil,
+          s(:int, 3)),
+        s(:empty_else)),
+      %q{case 1; in 2; 3; else; end},
+      %q{                 ~~~~ else},
+      SINCE_2_7
+    )
+  end
+
   def assert_pattern_matching_defines_local_variables(match_code, lvar_names, versions = SINCE_2_7)
     code = "case 1; #{match_code}; then [#{lvar_names.join(', ')}]; end"
 
@@ -9295,6 +9408,14 @@ class TestParser < Minitest::Test
       SINCE_2_7)
   end
 
+  def test_pattern_matching_required_bound_variable_before_pin
+    assert_diagnoses(
+      [:error, :undefined_lvar, { :name => 'a' }],
+      %{case 0; in ^a; true; end},
+      %{            ^ location},
+      SINCE_2_7)
+  end
+
   def test_parser_bug_645
     assert_parses(
       s(:block,

data/test/test_source_comment_associator.rb

@@ -31,16 +31,16 @@ class TestSourceCommentAssociator < Minitest::Test
     ast, associations = associate(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# class preceeding
-# another class preceeding
+# class preceding
+# another class preceding
 class Foo # class keyword line
-  # method foo preceeding
+  # method foo preceding
   def foo
     puts 'foo'
   end # method foo decorating
-  # method bar preceeding
+  # method bar preceding
   def bar
-    # expression preceeding
+    # expression preceding
     1 + # 1 decorating
       2
     # method bar sparse
@@ -58,8 +58,8 @@ end # class decorating
 
     assert_equal 6, associations.size
     assert_equal [
-      '# class preceeding',
-      '# another class preceeding',
+      '# class preceding',
+      '# another class preceding',
       '# class sparse',
       '# class decorating'
     ], associations[klass_node].map(&:text)
@@ -67,16 +67,16 @@ end # class decorating
       '# class keyword line'
     ], associations[klass_name_node].map(&:text)
     assert_equal [
-      '# method foo preceeding',
+      '# method foo preceding',
       '# method foo decorating'
     ], associations[foo_node].map(&:text)
     assert_equal [
-      '# method bar preceeding',
+      '# method bar preceding',
       '# method bar sparse',
       '# method bar decorating'
     ], associations[bar_node].map(&:text)
     assert_equal [
-      '# expression preceeding'
+      '# expression preceding'
     ], associations[expr_node].map(&:text)
     assert_equal [
       '# 1 decorating'
@@ -112,16 +112,16 @@ end
     ast, associations = associate_locations(<<-END)
 #!/usr/bin/env ruby
 # coding: utf-8
-# class preceeding
-# another class preceeding
+# class preceding
+# another class preceding
 class Foo # class keyword line
-  # method foo preceeding
+  # method foo preceding
   def foo
     puts 'foo'
   end # method foo decorating
-  # method bar preceeding
+  # method bar preceding
   def bar
-    # expression preceeding
+    # expression preceding
     1 + # 1 decorating
       2
     # method bar sparse
@@ -139,8 +139,8 @@ end # class decorating
 
     assert_equal 6, associations.size
     assert_equal [
-      '# class preceeding',
-      '# another class preceeding',
+      '# class preceding',
+      '# another class preceding',
       '# class sparse',
       '# class decorating'
     ], associations[klass_node.loc].map(&:text)
@@ -148,16 +148,16 @@ end # class decorating
       '# class keyword line'
     ], associations[klass_name_node.loc].map(&:text)
     assert_equal [
-      '# method foo preceeding',
+      '# method foo preceding',
       '# method foo decorating'
     ], associations[foo_node.loc].map(&:text)
     assert_equal [
-      '# method bar preceeding',
+      '# method bar preceding',
       '# method bar sparse',
       '# method bar decorating'
     ], associations[bar_node.loc].map(&:text)
     assert_equal [
-      '# expression preceeding'
+      '# expression preceding'
     ], associations[expr_node.loc].map(&:text)
     assert_equal [
       '# 1 decorating'

data/test/test_source_range.rb

@@ -169,4 +169,19 @@ class TestSourceRange < Minitest::Test
     assert_equal 1, sr3.begin_pos
     assert_equal 4, sr3.end_pos
   end
+
+  def test_eql_and_hash
+    assert_equal false, @sr1_3.eql?(@sr3_3)
+    assert @sr1_3.hash != @sr3_3.hash
+
+    also_1_3 = @sr3_3.with(begin_pos: 1)
+    assert_equal true, @sr1_3.eql?(also_1_3)
+    assert_equal @sr1_3.hash, also_1_3.hash
+
+    buf2 = Parser::Source::Buffer.new('(string)')
+    buf2.source = "foobar\nbaz"
+    from_other_buf = Parser::Source::Range.new(buf2, 1, 3)
+    assert_equal false, @sr1_3.eql?(from_other_buf)
+    assert @sr1_3.hash != from_other_buf.hash
+  end
 end

data/test/test_source_tree_rewriter.rb

@@ -8,8 +8,10 @@ class TestSourceTreeRewriter < Minitest::Test
     @buf.source = 'puts(:hello, :world)'
 
     @hello = range(5, 6)
+    @ll = range(7, 2)
     @comma_space = range(11,2)
     @world = range(13,6)
+    @whole = range(0, @buf.source.length)
   end
 
   def range(from, len)
@@ -17,11 +19,11 @@ class TestSourceTreeRewriter < Minitest::Test
   end
 
   # Returns either:
-  #  - String (Normal operation)
+  #  - yield rewriter
   #  - [diagnostic, ...] (Diagnostics)
   #  - Parser::ClobberingError
   #
-  def apply(actions, **policy)
+  def build(actions, **policy)
     diagnostics = []
     diags = -> { diagnostics.flatten.map(&:strip).join("\n") }
     rewriter = Parser::Source::TreeRewriter.new(@buf, **policy)
@@ -30,7 +32,7 @@ class TestSourceTreeRewriter < Minitest::Test
       rewriter.public_send(action, range, *args)
     end
     if diagnostics.empty?
-      rewriter.process
+      yield rewriter
     else
       diags.call
     end
@@ -38,6 +40,15 @@ class TestSourceTreeRewriter < Minitest::Test
     [::Parser::ClobberingError, diags.call]
   end
 
+  # Returns either:
+  #  - String (Normal operation)
+  #  - [diagnostic, ...] (Diagnostics)
+  #  - Parser::ClobberingError
+  #
+  def apply(actions, **policy)
+    build(actions, **policy) { |rewriter| rewriter.process }
+  end
+
   # Expects ordered actions to be grouped together
   def check_actions(expected, grouped_actions, **policy)
     grouped_actions.permutation do |sequence|
@@ -170,4 +181,73 @@ DIAGNOSTIC
     rewriter = Parser::Source::TreeRewriter.new(@buf)
     assert_raises(IndexError) { rewriter.insert_before(range(0, 100), 'hola') }
   end
+
+  def test_empty
+    rewriter = Parser::Source::TreeRewriter.new(@buf)
+    assert_equal true, rewriter.empty?
+
+    # This is a trivial wrap
+    rewriter.wrap(range(2,3), '', '')
+    assert_equal true, rewriter.empty?
+
+    # This is a trivial deletion
+    rewriter.remove(range(2,0))
+    assert_equal true, rewriter.empty?
+
+    rewriter.remove(range(2,3))
+    assert_equal false, rewriter.empty?
+  end
+
+  # splits array into two groups, yield all such possible pairs of groups
+  # each_split([1, 2, 3, 4]) yields [1, 2], [3, 4];
+  #                            then [1, 3], [2, 4]
+  #                                 ...
+  #                     and finally [3, 4], [1, 2]
+  def each_split(array)
+    n = array.size
+    first_split_size = n.div(2)
+    splitting = (0...n).to_set
+    splitting.to_a.combination(first_split_size) do |indices|
+      yield array.values_at(*indices),
+            array.values_at(*(splitting - indices))
+    end
+  end
+
+  # Checks that `actions+extra` give the same result when
+  # made in order or from subgroups that are later merged.
+  # The `extra` actions are always added at the end of the second group.
+  #
+  def check_all_merge_possibilities(actions, extra, **policy)
+    expected = apply(actions + extra, **policy)
+
+    each_split(actions) do |actions_1, actions_2|
+      build(actions_1, **policy) do |rewriter_1|
+        build(actions_2 + extra, **policy) do |rewriter_2|
+          result = rewriter_1.merge(rewriter_2).process
+          assert_equal(expected, result,
+            "Group 1: #{actions_1.inspect}\n\n" +
+            "Group 2: #{(actions_2 + extra).inspect}"
+          )
+        end
+      end
+    end
+  end
+
+  def test_merge
+    check_all_merge_possibilities([
+      [:wrap, @whole, '<', '>'],
+      [:replace, @comma_space, ' => '],
+      [:wrap, @hello, '!', '!'],
+      # Following two wraps must have same value as they
+      # will be applied in different orders...
+      [:wrap, @hello.join(@world), '{', '}'],
+      [:wrap, @hello.join(@world), '{', '}'],
+      [:remove, @ll],
+      [:replace, @world, ':everybody'],
+      [:wrap, @world, '[', ']']
+    ],
+    [ # ... but this one is always going to be applied last (extra)
+      [:wrap, @hello.join(@world), '@', '@'],
+    ])
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.7.0.2
+  version: 2.7.1.1
 platform: ruby
 authors:
 - whitequark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-08 00:00:00.000000000 Z
+date: 2020-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -295,7 +295,11 @@ files:
 homepage: https://github.com/whitequark/parser
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/whitequark/parser/issues
+  changelog_uri: https://github.com/whitequark/parser/blob/v2.7.1.1/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/parser/2.7.1.1
+  source_code_uri: https://github.com/whitequark/parser/tree/v2.7.1.1
 post_install_message: 
 rdoc_options: []
 require_paths: