parser 2.7.1.0 → 2.7.1.5

data/test/test_lexer.rb

@@ -37,9 +37,8 @@ class TestLexer < Minitest::Test
   end
 
   def assert_escape(expected, input)
-    source_buffer = Parser::Source::Buffer.new('(assert_escape)')
-
-    source_buffer.source = "\"\\#{input}\"".encode(input.encoding)
+    source_buffer = Parser::Source::Buffer.new('(assert_escape)',
+      source: "\"\\#{input}\"".encode(input.encoding))
 
     @lex.reset
     @lex.source_buffer = source_buffer
@@ -71,8 +70,7 @@ class TestLexer < Minitest::Test
   end
 
   def assert_scanned(input, *args)
-    source_buffer = Parser::Source::Buffer.new('(assert_scanned)')
-    source_buffer.source = input
+    source_buffer = Parser::Source::Buffer.new('(assert_scanned)', source: input)
 
     @lex.reset(false)
     @lex.source_buffer = source_buffer
@@ -3569,14 +3567,25 @@ class TestLexer < Minitest::Test
                    :tIDENTIFIER, 're', [1, 3])
   end
 
+  def test_endless_method
+    setup_lexer(30)
+
+    assert_scanned('def foo() = 42',
+                    :kDEF, "def", [0, 3],
+                    :tIDENTIFIER, "foo", [4, 7],
+                    :tLPAREN2, "(", [7, 8],
+                    :tRPAREN, ")", [8, 9],
+                    :tEQL, "=", [10, 11],
+                    :tINTEGER, 42, [12, 14])
+  end
+
   def lex_numbered_parameter(input)
     @lex.max_numparam_stack.push
 
     @lex.context = Parser::Context.new
     @lex.context.push(:block)
 
-    source_buffer = Parser::Source::Buffer.new('(assert_lex_numbered_parameter)')
-    source_buffer.source = input
+    source_buffer = Parser::Source::Buffer.new('(assert_lex_numbered_parameter)', source: input)
 
     @lex.source_buffer = source_buffer
 
@@ -3594,7 +3603,7 @@ class TestLexer < Minitest::Test
 
   def refute_scanned_numbered_parameter(input, message = nil)
     err = assert_raises Parser::SyntaxError do
-      lex_token, (lex_value, lex_range) = lex_numbered_parameter(input)
+      _lex_token, (_lex_value, _lex_range) = lex_numbered_parameter(input)
     end
 
     if message

data/test/test_meta.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestMeta < Minitest::Test
+  def test_NODE_TYPES
+    for_each_node do |node|
+      assert Parser::Meta::NODE_TYPES.include?(node.type),
+            "Type #{node.type} missing from Parser::Meta::NODE_TYPES"
+    end
+  end
+end

data/test/test_parse_helper.rb

@@ -25,33 +25,36 @@ class TestParseHelper < Minitest::Test
   end
 
   def test_parse_mapsation_description
-    assert_equal [[0, 4, 'expr', [], '~~~~ expr']],
+    assert_equal [[0...4, 'expr', [], '~~~~ expr']],
                  parse_maps('~~~~ expr')
 
-    assert_equal [[0, 4, 'expr', [], '^~~~ expr']],
+    assert_equal [[0...4, 'expr', [], '^~~~ expr']],
                  parse_maps('^~~~ expr')
 
-    assert_equal [[0, 4, 'expr', [], '^^^^ expr']],
+    assert_equal [[0...4, 'expr', [], '^^^^ expr']],
                  parse_maps('^^^^ expr')
 
-    assert_equal [[2, 3, 'op', [], '  ^ op']],
+    assert_equal [[2...3, 'op', [], '  ^ op']],
                  parse_maps('  ^ op')
 
-    assert_equal [[2, 3, 'op', ['foo'], '  ~ op (foo)']],
+    assert_equal [[2...3, 'op', ['foo'], '  ~ op (foo)']],
                  parse_maps('  ~ op (foo)')
 
-    assert_equal [[2, 4, 'op', ['foo', 'bar'], '  ~~ op (foo.bar)']],
+    assert_equal [[2...4, 'op', ['foo', 'bar'], '  ~~ op (foo.bar)']],
                  parse_maps('  ~~ op (foo.bar)')
 
-    assert_equal [[2, 4, 'op', ['foo/2', 'bar'], '  ~~ op (foo/2.bar)']],
+    assert_equal [[2...4, 'op', ['foo/2', 'bar'], '  ~~ op (foo/2.bar)']],
                  parse_maps('  ~~ op (foo/2.bar)')
 
-    assert_equal [[0, 4, 'expr', [], '~~~~ expr'],
-                  [5, 7, 'op', ['str', 'e_h'], '     ~~ op (str.e_h)']],
+    assert_equal [[0...4, 'expr', [], '~~~~ expr'],
+                  [5...7, 'op', ['str', 'e_h'], '     ~~ op (str.e_h)']],
                  parse_maps(%{
                             |~~~~ expr
                             |     ~~ op (str.e_h)
                             })
+
+    assert_equal [[nil, 'expr', [], '! expr']],
+                 parse_maps('! expr')
   end
 
   def test_traverse_ast

data/test/test_parser.rb

@@ -29,6 +29,7 @@ class TestParser < Minitest::Test
   SINCE_2_5 = SINCE_2_4 - %w(2.4)
   SINCE_2_6 = SINCE_2_5 - %w(2.5)
   SINCE_2_7 = SINCE_2_6 - %w(2.6)
+  SINCE_3_0 = SINCE_2_7 - %w(2.7)
 
   # Guidelines for test naming:
   #  * Test structure follows structure of AST_FORMAT.md.
@@ -1855,6 +1856,7 @@ class TestParser < Minitest::Test
       %q{def foo; end},
       %q{~~~ keyword
         |    ~~~ name
+        |! assignment
         |         ~~~ end})
 
     assert_parses(
@@ -1975,7 +1977,9 @@ class TestParser < Minitest::Test
       %q{alias :foo bar},
       %q{~~~~~ keyword
         |      ~~~~ expression (sym/1)
+        |      ^ begin (sym/1)
         |           ~~~ expression (sym/2)
+        |           ! begin (sym/2)
         |~~~~~~~~~~~~~~ expression})
   end
 
@@ -5359,8 +5363,7 @@ class TestParser < Minitest::Test
 
   def test_crlf_line_endings
     with_versions(ALL_VERSIONS) do |_ver, parser|
-      source_file = Parser::Source::Buffer.new('(comments)')
-      source_file.source = "\r\nfoo"
+      source_file = Parser::Source::Buffer.new('(comments)', source: "\r\nfoo")
 
       range = lambda do |from, to|
         Parser::Source::Range.new(source_file, from, to)
@@ -5433,8 +5436,7 @@ class TestParser < Minitest::Test
     with_versions(ALL_VERSIONS) do |_ver, parser|
       parser.builder.emit_file_line_as_literals = false
 
-      source_file = Parser::Source::Buffer.new('(comments)')
-      source_file.source = "[__FILE__, __LINE__]"
+      source_file = Parser::Source::Buffer.new('(comments)', source: "[__FILE__, __LINE__]")
 
       ast = parser.parse(source_file)
 
@@ -5518,8 +5520,7 @@ class TestParser < Minitest::Test
 
   def assert_parses_with_comments(ast_pattern, source, comments_pattern)
     with_versions(ALL_VERSIONS) do |_ver, parser|
-      source_file = Parser::Source::Buffer.new('(comments)')
-      source_file.source = source
+      source_file = Parser::Source::Buffer.new('(comments)', source: source)
 
       comments_pattern_here = comments_pattern.map do |(from, to)|
         range = Parser::Source::Range.new(source_file, from, to)
@@ -5550,8 +5551,8 @@ class TestParser < Minitest::Test
 
   def test_tokenize
     with_versions(ALL_VERSIONS) do |_ver, parser|
-      source_file = Parser::Source::Buffer.new('(tokenize)')
-      source_file.source = "1 + # foo\n 2"
+      source_file = Parser::Source::Buffer.new('(tokenize)',
+        source: "1 + # foo\n 2")
 
       range = lambda do |from, to|
         Parser::Source::Range.new(source_file, from, to)
@@ -5577,8 +5578,8 @@ class TestParser < Minitest::Test
 
   def test_tokenize_recover
     with_versions(ALL_VERSIONS) do |_ver, parser|
-      source_file = Parser::Source::Buffer.new('(tokenize)')
-      source_file.source = "1 + # foo\n "
+      source_file = Parser::Source::Buffer.new('(tokenize)',
+        source: "1 + # foo\n ")
 
       range = lambda do |from, to|
         Parser::Source::Range.new(source_file, from, to)
@@ -6553,39 +6554,64 @@ class TestParser < Minitest::Test
 
   def test_context_class
     [
-      %q{class A;},
-      %q{class A < B;}
+      %q{class A; get_context; end},
+      %q{class A < B; get_context; end}
     ].each do |code|
       assert_context([:class], code, ALL_VERSIONS)
     end
   end
 
+  def test_context_module
+    assert_context(
+      [:module],
+      %q{module M; get_context; end},
+      ALL_VERSIONS)
+  end
+
   def test_context_sclass
     assert_context(
       [:sclass],
-      %q{class << foo;},
+      %q{class << foo; get_context; end},
       ALL_VERSIONS)
   end
 
   def test_context_def
-    assert_context(
-      [:def],
-      %q{def m;},
-      ALL_VERSIONS)
+    [
+      %q{def m; get_context; end},
+      %q{def m(a = get_context); end}
+    ].each do |code|
+      assert_context([:def], code, ALL_VERSIONS)
+    end
+
+    [
+      %q{def m() = get_context},
+      %q{def m(a = get_context) = 42}
+    ].each do |code|
+      assert_context([:def], code, SINCE_3_0)
+    end
   end
 
   def test_context_defs
-    assert_context(
-      [:defs],
-      %q{def foo.m;},
-      ALL_VERSIONS)
+    [
+      %q{def foo.m; get_context; end},
+      %q{def foo.m(a = get_context); end}
+    ].each do |code|
+      assert_context([:defs], code, ALL_VERSIONS)
+    end
+
+    [
+      %q{def foo.m() = get_context},
+      %q{def foo.m(a = get_context) = 42}
+    ].each do |code|
+      assert_context([:defs], code, SINCE_3_0)
+    end
   end
 
   def test_context_cmd_brace_block
     [
-      'tap foo {',
-      'foo.tap foo {',
-      'foo::tap foo {'
+      'tap foo { get_context }',
+      'foo.tap foo { get_context }',
+      'foo::tap foo { get_context }'
     ].each do |code|
       assert_context([:block], code, ALL_VERSIONS)
     end
@@ -6593,12 +6619,12 @@ class TestParser < Minitest::Test
 
   def test_context_brace_block
     [
-      'tap {',
-      'foo.tap {',
-      'foo::tap {',
-      'tap do',
-      'foo.tap do',
-      'foo::tap do'
+      'tap { get_context }',
+      'foo.tap { get_context }',
+      'foo::tap { get_context }',
+      'tap do get_context end',
+      'foo.tap do get_context end',
+      'foo::tap do get_context end'
     ].each do |code|
       assert_context([:block], code, ALL_VERSIONS)
     end
@@ -6606,9 +6632,9 @@ class TestParser < Minitest::Test
 
   def test_context_do_block
     [
-      %q{tap 1 do},
-      %q{foo.tap do},
-      %q{foo::tap do}
+      %q{tap 1 do get_context end},
+      %q{foo.tap do get_context end},
+      %q{foo::tap do get_context end}
     ].each do |code|
       assert_context([:block], code, ALL_VERSIONS)
     end
@@ -6616,8 +6642,12 @@ class TestParser < Minitest::Test
 
   def test_context_lambda
     [
-      '->() {',
-      '->() do'
+      '->() { get_context }',
+      '->() do get_context end',
+      '-> { get_context }',
+      '-> do get_context end',
+      '->(a = get_context) {}',
+      '->(a = get_context) do end'
     ].each do |code|
       assert_context([:lambda], code, SINCE_1_9)
     end
@@ -6625,28 +6655,61 @@ class TestParser < Minitest::Test
 
   def test_context_nested
     assert_context(
-      [:class, :sclass, :defs, :def, :block],
-      %q{class A; class << foo; def bar.m; def m; tap do},
+      [:class, :module, :sclass, :defs, :def, :block],
+      %q{
+        class A
+          module M
+            class << foo
+              def bar.m
+                def m
+                  tap do
+                    get_context
+                  end
+                end
+              end
+            end
+          end
+        end
+      },
       ALL_VERSIONS)
 
     assert_context(
-      [:class, :sclass, :defs, :def, :lambda, :block],
-      %q{class A; class << foo; def bar.m; def m; -> do; tap do},
+      [:class, :module, :sclass, :defs, :def, :lambda, :block],
+      %q{
+        class A
+          module M
+            class << foo
+              def bar.m
+                def m
+                  -> do
+                    tap do
+                      get_context
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      },
       SINCE_1_9)
 
     assert_context(
       [],
       %q{
         class A
-          class << foo
-            def bar.m
-              def m
-                tap do
+          module M
+            class << foo
+              def bar.m
+                def m
+                  tap do
+                  end
                 end
               end
             end
           end
         end
+        get_context
       },
       ALL_VERSIONS)
 
@@ -6654,17 +6717,20 @@ class TestParser < Minitest::Test
       [],
       %q{
         class A
-          class << foo
-            def bar.m
-              def m
-                -> do
-                  tap do
+          module M
+            class << foo
+              def bar.m
+                def m
+                  -> do
+                    tap do
+                    end
                   end
                 end
               end
             end
           end
         end
+        get_context
       },
       SINCE_1_9)
   end
@@ -7448,7 +7514,7 @@ class TestParser < Minitest::Test
           s(:nil))),
       %q{proc {_1 = nil}},
       %q{},
-      SINCE_2_7)
+      %w(2.7))
 
     assert_diagnoses(
       [:error, :cant_assign_to_numparam, { :name => '_1' }],
@@ -7476,7 +7542,7 @@ class TestParser < Minitest::Test
 
     refute_diagnoses(
       %q{proc { _1 = nil; _1}},
-      SINCE_2_7)
+      %w(2.7))
   end
 
   def test_numparams_in_nested_blocks
@@ -7748,7 +7814,8 @@ class TestParser < Minitest::Test
     end
   end
 
-  def test_forward_args
+  def test_forward_args_legacy
+    Parser::Builders::Default.emit_forward_arg = false
     assert_parses(
       s(:def, :foo,
         s(:forward_args),
@@ -7780,7 +7847,27 @@ class TestParser < Minitest::Test
       %q{def foo(...); end},
       %q{},
       SINCE_2_7)
+  ensure
+    Parser::Builders::Default.emit_forward_arg = true
+  end
+
+  def test_forward_arg
+    assert_parses(
+      s(:def, :foo,
+        s(:args,
+          s(:forward_arg)),
+        s(:send, nil, :bar,
+          s(:forwarded_args))),
+      %q{def foo(...); bar(...); end},
+      %q{       ~ begin (args)
+        |       ~~~~~ expression (args)
+        |           ~ end (args)
+        |        ~~~ expression (args.forward_arg)
+        |                  ~~~ expression (send.forwarded_args)},
+      SINCE_2_7)
+  end
 
+  def test_forward_args_invalid
     assert_diagnoses(
       [:error, :block_and_blockarg],
       %q{def foo(...) bar(...) { }; end},
@@ -7806,6 +7893,12 @@ class TestParser < Minitest::Test
       %q{                    ^^^ location},
       SINCE_2_7)
 
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tBDOT3' }],
+      %q{def foo(x,y,z); bar(x, y, z, ...); end},
+      %q{                             ^^^ location},
+      SINCE_3_0)
+
     assert_diagnoses(
       [:error, :unexpected_token, { :token => 'tBDOT3' }],
       %q{def foo(x,y,z); super(...); end},
@@ -7822,7 +7915,13 @@ class TestParser < Minitest::Test
       [:error, :unexpected_token, { :token => 'tBDOT3' }],
       %q{->(...) {}},
       %q{   ^^^ location},
-      SINCE_2_7)
+      ['2.7'])
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tDOT3' }],
+      %q{->(...) {}},
+      %q{   ^^^ location},
+      SINCE_3_0)
 
     # Here and below the parser asssumes that
     # it can be a beginningless range, so the error comes after reducing right paren
@@ -7875,6 +7974,26 @@ class TestParser < Minitest::Test
       SINCE_2_7)
   end
 
+  def test_trailing_forward_arg
+    assert_parses(
+      s(:def, :foo,
+        s(:args,
+          s(:arg, :a),
+          s(:arg, :b),
+          s(:forward_arg)),
+        s(:send, nil, :bar,
+          s(:lvar, :a),
+          s(:int, 42),
+          s(:forwarded_args))),
+      %q{def foo(a, b, ...); bar(a, 42, ...); end},
+      %q{       ~ begin (args)
+        |       ~~~~~~~~~~~ expression (args)
+        |                 ~ end (args)
+        |              ~~~ expression (args.forward_arg)},
+      SINCE_3_0)
+  end
+
+
   def test_erange_without_parentheses_at_eol
     assert_diagnoses(
       [:warning, :triple_dot_at_eol],
@@ -8344,7 +8463,7 @@ class TestParser < Minitest::Test
         nil),
       "#{case_pre}#{code}; end",
       source_maps,
-      SINCE_2_7
+      versions
     )
   end
 
@@ -8790,6 +8909,21 @@ class TestParser < Minitest::Test
       %q{}
     )
 
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:hash_pattern,
+          s(:pair,
+             s(:sym, :Foo),
+             s(:int, 42))), nil,
+        s(:false)),
+      %q{
+        in {Foo: 42
+        }
+          false
+      },
+      %q{}
+    )
+
     assert_parses_pattern_match(
       s(:in_pattern,
         s(:hash_pattern,
@@ -8933,6 +9067,22 @@ class TestParser < Minitest::Test
       %q{           ~~~~~~~ location},
       SINCE_2_7
     )
+
+    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_invalid_lvar_name
+    assert_diagnoses(
+      [:error, :lvar_name, { name: :a? }],
+      %q{case a; in a?:; end},
+      %q{           ~~ location},
+      SINCE_2_7
+    )
   end
 
   def test_pattern_matching_keyword_variable
@@ -9210,8 +9360,7 @@ class TestParser < Minitest::Test
     code = "case 1; #{match_code}; then [#{lvar_names.join(', ')}]; end"
 
     with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_context)')
-      source_file.source = code
+      source_file = Parser::Source::Buffer.new('(assert_context)', source: code)
 
       lvar_names.each do |lvar_name|
         refute parser.static_env.declared?(lvar_name),
@@ -9221,7 +9370,7 @@ class TestParser < Minitest::Test
       before = parser.static_env.instance_variable_get(:@variables).to_a
 
       begin
-        parsed_ast = parser.parse(source_file)
+        _parsed_ast = parser.parse(source_file)
       rescue Parser::SyntaxError => exc
         backtrace = exc.backtrace
         Exception.instance_method(:initialize).bind(exc).
@@ -9427,4 +9576,411 @@ class TestParser < Minitest::Test
       %{},
       SINCE_1_9)
   end
+
+  def test_endless_method
+    assert_parses(
+      s(:def, :foo,
+        s(:args),
+        s(:int, 42)),
+      %q{def foo() = 42},
+      %q{~~~ keyword
+        |    ~~~ name
+        |          ^ assignment
+        |! end
+        |~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:def, :inc,
+        s(:args, s(:arg, :x)),
+        s(:send,
+          s(:lvar, :x), :+,
+          s(:int, 1))),
+      %q{def inc(x) = x + 1},
+      %q{~~~ keyword
+        |    ~~~ name
+        |           ^ assignment
+        |~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:defs, s(:send, nil, :obj), :foo,
+        s(:args),
+        s(:int, 42)),
+      %q{def obj.foo() = 42},
+      %q{~~~ keyword
+        |       ^ operator
+        |        ~~~ name
+        |              ^ assignment
+        |~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:defs, s(:send, nil, :obj), :inc,
+        s(:args, s(:arg, :x)),
+        s(:send,
+          s(:lvar, :x), :+,
+          s(:int, 1))),
+      %q{def obj.inc(x) = x + 1},
+      %q{~~~ keyword
+        |        ~~~ name
+        |       ^ operator
+        |               ^ assignment
+        |~~~~~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+  end
+
+  def test_endless_method_forwarded_args_legacy
+    Parser::Builders::Default.emit_forward_arg = false
+    assert_parses(
+      s(:def, :foo,
+        s(:forward_args),
+        s(:send, nil, :bar,
+          s(:forwarded_args))),
+      %q{def foo(...) = bar(...)},
+      %q{~~~ keyword
+        |    ~~~ name
+        |             ^ assignment
+        |~~~~~~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+    Parser::Builders::Default.emit_forward_arg = true
+  end
+
+  def test_endless_method_without_brackets
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tEQL' }],
+      %Q{def foo = 42},
+      %q{        ^ location},
+      SINCE_3_0)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tEQL' }],
+      %Q{def obj.foo = 42},
+      %q{            ^ location},
+      SINCE_3_0
+    )
+  end
+
+  def test_endless_method_with_rescue_mod
+    assert_parses(
+      s(:def, :m,
+        s(:args),
+        s(:rescue,
+          s(:int, 1),
+          s(:resbody, nil, nil,
+            s(:int, 2)), nil)),
+      %q{def m() = 1 rescue 2},
+      %q{},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:defs,
+        s(:self), :m,
+        s(:args),
+        s(:rescue,
+          s(:int, 1),
+          s(:resbody, nil, nil,
+            s(:int, 2)), nil)),
+      %q{def self.m() = 1 rescue 2},
+      %q{},
+      SINCE_3_0)
+  end
+
+  def test_rasgn
+    assert_parses(
+      s(:lvasgn, :a,
+        s(:int, 1)),
+      %q{1 => a},
+      %q{~~~~~~ expression
+        |  ^^ operator},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:gvasgn, :$a,
+        s(:send, s(:int, 1), :+, s(:int, 2))),
+      %q{1 + 2 => $a},
+      %q{~~~~~~~~~~~ expression
+        |      ^^ operator},
+      SINCE_3_0)
+  end
+
+  def test_mrasgn
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+        s(:send, s(:int, 13), :divmod, s(:int, 5))),
+      %q{13.divmod(5) => a,b},
+      %q{~~~~~~~~~~~~~~~~~~~ expression
+        |             ^^ operator},
+      SINCE_3_0)
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :c), s(:lvasgn, :d)),
+        s(:masgn,
+          s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+          s(:send, s(:int, 13), :divmod, s(:int, 5))),
+        ),
+      %q{13.divmod(5) => a,b => c, d},
+      %q{~~~~~~~~~~~~~~~~~~~ expression (masgn)
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_3_0)
+  end
+
+  def test_rasgn_line_continuation
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tASSOC' }],
+      %Q{13.divmod(5)\n=> a,b; [a, b]},
+      %{             ^^ location},
+      SINCE_3_0)
+  end
+
+  def test_find_pattern
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:find_pattern,
+          s(:match_rest,
+            s(:match_var, :x)),
+          s(:match_as,
+            s(:int, 1),
+            s(:match_var, :a)),
+          s(:match_rest,
+            s(:match_var, :y))),
+        nil,
+        s(:true)),
+      %q{in [*x, 1 => a, *y] then true},
+      %q{   ~~~~~~~~~~~~~~~~ expression (in_pattern.find_pattern)
+        |   ~ begin (in_pattern.find_pattern)
+        |                  ~ end (in_pattern.find_pattern)
+        |    ~~ expression (in_pattern.find_pattern.match_rest/1)
+        |                ~~ expression (in_pattern.find_pattern.match_rest/2)},
+      SINCE_3_0)
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:const_pattern,
+          s(:const, nil, :String),
+          s(:find_pattern,
+            s(:match_rest),
+            s(:int, 1),
+            s(:match_rest))),
+        nil,
+        s(:true)),
+      %q{in String(*, 1, *) then true},
+      %q{          ~~~~~~~ expression (in_pattern.const_pattern.find_pattern)},
+      SINCE_3_0)
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:const_pattern,
+          s(:const, nil, :Array),
+          s(:find_pattern,
+            s(:match_rest),
+            s(:int, 1),
+            s(:match_rest))),
+        nil,
+        s(:true)),
+      %q{in Array[*, 1, *] then true},
+      %q{         ~~~~~~~ expression (in_pattern.const_pattern.find_pattern)},
+      SINCE_3_0)
+
+    assert_parses_pattern_match(
+      s(:in_pattern,
+        s(:find_pattern,
+          s(:match_rest),
+          s(:int, 42),
+          s(:match_rest)),
+        nil,
+        s(:true)),
+      %q{in *, 42, * then true},
+      %q{   ~~~~~~~~ expression (in_pattern.find_pattern)},
+      SINCE_3_0)
+  end
+
+  def test_invalid_source
+    with_versions(ALL_VERSIONS) do |_ver, parser|
+      source_file = Parser::Source::Buffer.new('(comments)', source: "def foo; en")
+
+      parser.diagnostics.all_errors_are_fatal = false
+      ast = parser.parse(source_file)
+      assert_nil(ast)
+    end
+  end
+
+  def test_reserved_for_numparam__before_30
+    assert_parses(
+      s(:block,
+        s(:send, nil, :proc),
+        s(:args),
+        s(:lvasgn, :_1,
+          s(:nil))),
+      %q{proc {_1 = nil}},
+      %q{},
+      ALL_VERSIONS - SINCE_3_0)
+
+    assert_parses(
+      s(:lvasgn, :_2,
+        s(:int, 1)),
+      %q{_2 = 1},
+      %q{},
+      ALL_VERSIONS - SINCE_3_0)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :proc),
+        s(:args,
+          s(:procarg0,
+            s(:arg, :_3))), nil),
+      %q{proc {|_3|}},
+      %q{},
+      SINCE_1_9 - SINCE_3_0)
+
+    assert_parses(
+      s(:def, :x,
+        s(:args,
+          s(:arg, :_4)), nil),
+      %q{def x(_4) end},
+      %q{},
+      ALL_VERSIONS - SINCE_3_0)
+
+    assert_parses(
+      s(:def, :_5,
+        s(:args), nil),
+      %q{def _5; end},
+      %q{},
+      ALL_VERSIONS - SINCE_3_0)
+
+    assert_parses(
+      s(:defs,
+        s(:self), :_6,
+        s(:args), nil),
+      %q{def self._6; end},
+      %q{},
+      ALL_VERSIONS - SINCE_3_0)
+  end
+
+  def test_reserved_for_numparam__since_30
+    # Regular assignments:
+
+    assert_diagnoses(
+      [:error, :reserved_for_numparam, { :name => '_1' }],
+      %q{proc {_1 = nil}},
+      %q{      ^^ location},
+      SINCE_3_0)
+
+    assert_diagnoses(
+      [:error, :reserved_for_numparam, { :name => '_2' }],
+      %q{_2 = 1},
+      %q{^^ location},
+      SINCE_3_0)
+
+    # Arguments:
+
+    [
+      # req (procarg0)
+      [
+        %q{proc {|_3|}},
+        %q{       ^^ location},
+      ],
+
+      # req
+      [
+        %q{proc {|_3,|}},
+        %q{       ^^ location},
+      ],
+
+      # opt
+      [
+        %q{proc {|_3 = 42|}},
+        %q{       ^^ location},
+      ],
+
+      # mlhs
+      [
+        %q{proc {|(_3)|}},
+        %q{        ^^ location},
+      ],
+
+      # rest
+      [
+        %q{proc {|*_3|}},
+        %q{        ^^ location},
+      ],
+
+      # kwarg
+      [
+        %q{proc {|_3:|}},
+        %q{       ^^^ location},
+      ],
+
+      # kwoptarg
+      [
+        %q{proc {|_3: 42|}},
+        %q{       ^^^ location},
+      ],
+
+      # kwrestarg
+      [
+        %q{proc {|**_3|}},
+        %q{         ^^ location},
+      ],
+
+      # block
+      [
+        %q{proc {|&_3|}},
+        %q{        ^^ location},
+      ],
+
+      # shadowarg
+      [
+        %q{proc {|;_3|}},
+        %q{        ^^ location},
+      ],
+    ].each do |(code, location)|
+      assert_diagnoses(
+        [:error, :reserved_for_numparam, { :name => '_3' }],
+        code,
+        location,
+        SINCE_3_0)
+    end
+
+    # Method definitions:
+
+    [
+      # regular method
+      [
+        %q{def _5; end},
+        %q{    ^^ location}
+      ],
+      # regular singleton method
+      [
+        %q{def self._5; end},
+        %q{         ^^ location}
+      ],
+      # endless method
+      [
+        %q{def _5() = nil},
+        %q{    ^^ location}
+      ],
+      # endless singleton method
+      [
+        %q{def self._5() = nil},
+        %q{         ^^ location}
+      ],
+    ].each do |(code, location)|
+      assert_diagnoses(
+        [:error, :reserved_for_numparam, { :name => '_5' }],
+        code,
+        location,
+        SINCE_3_0)
+    end
+  end
+
+  def test_endless_setter
+    assert_diagnoses(
+      [:error, :endless_setter],
+      %q{def foo=() = 42},
+      %q{    ^^^^ location},
+      SINCE_3_0)
+  end
 end