parser 2.7.0.1 → 2.7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 343568dc3db7c4cb37b68cdef2a241b86e639fea958156014ab0b701b0d04426
-  data.tar.gz: 320c9f744d2ae76c16efb8e70f021ae35faa8bc89251ff211690085cdf7f2fe3
+  metadata.gz: 46184af7a1e0d843e62e720cd7795bb196972603e588eed69f47791b3c799288
+  data.tar.gz: 1a9d809fc7443fb09deb3a36ea19ad418ff56119040b14a292c9ed8d112d1f29
 SHA512:
-  metadata.gz: dc4f82ed4f56061e57952b794f44d039d456bf43b2e805020233e20569908ce95e788520b2642c33bc2838860a80fe5308959fc3c994bcbc48739ca1ca3aed6a
-  data.tar.gz: 4b4cc6603bef9ca16925bcb009d0b1ed17c3fb22125a0c2b8eb2ea6c631664cea26e466aa7bacbff9b73040a37341cc107f678edc5f81c22745086b011b46b6a
+  metadata.gz: 9a91995ac131a4048976358a7bce1bd09b09893bb0b13fa39f2128c47fb0b1179f830a4adbb766df768bfbd2f89a1c5a5ee437dc1433ccaf5ad2307ff7c09d77
+  data.tar.gz: 4fe835bc9fe1ff030d57e9a4d9a4657a0d244db23bac3c117e8f78bfc51d9dc330f51257e04c8ba5ef737d3feab11152db2e1ecde1e8b136d4fcc4f253ed549d

data/.travis.yml

@@ -2,23 +2,17 @@ dist: trusty
 language: ruby
 matrix:
   include:
-    - name: 2.0.0 / Parser tests
-      rvm: 2.0.0
-      script: bundle exec rake test_cov
-    - name: 2.2.10 / Parser tests
-      rvm: 2.2.10
-      script: bundle exec rake test_cov
-    - name: 2.3.8 / Parser tests
-      rvm: 2.3.8
-      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
+    - name: 2.5.8 / Parser tests
+      rvm: 2.5.8
       script: bundle exec rake test_cov
-    - name: 2.6.5 / Parser tests
-      rvm: 2.6.5
+    - name: 2.6.6 / Parser tests
+      rvm: 2.6.6
+      script: bundle exec rake test_cov
+    - name: 2.7.1 / Parser tests
+      rvm: 2.7.1
       script: bundle exec rake test_cov
     - name: ruby-head / Parser tests
       rvm: ruby-head
@@ -29,11 +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.6 / Rubocop tests
+      rvm: 2.6.6
       script: ./ci/run_rubocop_specs
-    - name: 2.6.5 / Rubocop tests
-      rvm: 2.6.5
+    - 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,40 @@
 Changelog
 =========
 
-Not released (2019-12-30)
+Not released (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)
+
+v2.7.0.1 (2019-12-30)
+---------------------
+
 Bugs fixed:
  * dedenter.rb: prevent `ArgumentError` when processing binary en… (#642) (Koichi ITO)
 

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

@@ -1064,7 +1064,6 @@ class Parser::Lexer
           emit(:tRCURLY, '}'.freeze, p - 1, p)
           @cond.lexpop
           @cmdarg.lexpop
-          @paren_nest -= 1
         else
           emit(:tSTRING_DEND, '}'.freeze, p - 1, p)
         end
@@ -1079,6 +1078,8 @@ class Parser::Lexer
         fbreak;
       end
     end
+
+    @paren_nest -= 1
   };
 
   action extend_interp_code {
@@ -2165,6 +2166,9 @@ class Parser::Lexer
             emit_do
           end
         end
+        if tok == '{'.freeze
+          @paren_nest += 1
+        end
         @command_start = true
 
         fnext expr_value; fbreak;
@@ -2469,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/tree_rewriter/action.rb

@@ -56,11 +56,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]

data/lib/parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parser
-  VERSION = '2.7.0.1'
+  VERSION = '2.7.1.0'
 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/parse_helper.rb

@@ -127,6 +127,9 @@ module ParseHelper
 
     assert parser.instance_eval { @lexer }.cmdarg.empty?,
       "(#{version}) expected cmdarg to be empty after parsing"
+
+    assert_equal 0, parser.instance_eval { @lexer.instance_eval { @paren_nest } },
+      "(#{version}) expected paren_nest to be 0 after parsing"
   end
 
   # Use like this:

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"
 
@@ -9294,4 +9407,24 @@ class TestParser < Minitest::Test
       %{     ^^ location},
       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,
+        s(:lambda),
+        s(:args,
+          s(:optarg, :arg,
+            s(:hash))), nil),
+      '-> (arg={}) {}',
+      %{},
+      SINCE_1_9)
+  end
 end

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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.7.0.1
+  version: 2.7.1.0
 platform: ruby
 authors:
 - whitequark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-30 00:00:00.000000000 Z
+date: 2020-04-03 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.0/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/parser/2.7.1.0
+  source_code_uri: https://github.com/whitequark/parser/tree/v2.7.1.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -311,7 +315,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A Ruby parser written in pure Ruby.