parser 2.7.1.4 → 2.7.1.5

data/lib/parser/rubymotion.y

@@ -512,7 +512,7 @@ rule
 
             fsym: fname
                     {
-                      result = @builder.symbol(val[0])
+                      result = @builder.symbol_internal(val[0])
                     }
                 | symbol
 

data/lib/parser/runner.rb

@@ -113,9 +113,9 @@ module Parser
         @parser_class = Parser::Ruby27
       end
 
-      opts.on '--28', 'Parse as Ruby 2.8 would' do
-        require 'parser/ruby28'
-        @parser_class = Parser::Ruby28
+      opts.on '--30', 'Parse as Ruby 3.0 would' do
+        require 'parser/ruby30'
+        @parser_class = Parser::Ruby30
       end
 
       opts.on '--mac', 'Parse as MacRuby 0.12 would' do

data/lib/parser/source/comment.rb

@@ -10,7 +10,7 @@ module Parser
     #  @return [String]
     #
     # @!attribute [r] location
-    #  @return [Parser::Source::Map]
+    #  @return [Parser::Source::Range]
     #
     # @api public
     #

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

@@ -107,7 +107,7 @@ module Parser
 
       private
 
-      POSTFIX_TYPES = Set[:if, :while, :while_post, :until, :until_post].freeze
+      POSTFIX_TYPES = Set[:if, :while, :while_post, :until, :until_post, :masgn].freeze
       def children_in_source_order(node)
         if POSTFIX_TYPES.include?(node.type)
           # All these types have either nodes with expressions, or `nil`

data/lib/parser/source/map/{endless_definition.rb → method_definition.rb}

@@ -3,19 +3,21 @@
 module Parser
   module Source
 
-    class Map::EndlessDefinition < Map
+    class Map::MethodDefinition < Map
       attr_reader :keyword
       attr_reader :operator
       attr_reader :name
+      attr_reader :end
       attr_reader :assignment
 
-      def initialize(keyword_l, operator_l, name_l, assignment_l, body_l)
+      def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l)
         @keyword  = keyword_l
         @operator = operator_l
         @name     = name_l
+        @end      = end_l
         @assignment = assignment_l
 
-        super(@keyword.join(body_l))
+        super(@keyword.join(end_l || body_l))
       end
     end
 

data/lib/parser/source/range.rb

@@ -112,11 +112,11 @@ module Parser
       # @raise RangeError
       #
       def column_range
-        if self.begin.line != self.end.line
+        if line != last_line
           raise RangeError, "#{self.inspect} spans more than one line"
         end
 
-        self.begin.column...self.end.column
+        column...last_column
       end
 
       ##

data/lib/parser/version.rb

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

data/parser.gemspec

@@ -32,10 +32,13 @@ Gem::Specification.new do |spec|
                           lib/parser/ruby25.rb
                           lib/parser/ruby26.rb
                           lib/parser/ruby27.rb
-                          lib/parser/ruby28.rb
+                          lib/parser/ruby30.rb
                           lib/parser/macruby.rb
                           lib/parser/rubymotion.rb
+                       ) - %w(
+                          .gitignore
                        )
+
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^test/})
   spec.require_paths = ['lib']

data/test/helper.rb

@@ -18,7 +18,7 @@ if ENV.include?('COVERAGE') && SimpleCov.usable?
       ruby25.y
       ruby26.y
       ruby27.y
-      ruby28.y
+      ruby30.y
     ),
     File.expand_path('../../lib/parser', __FILE__))
 

data/test/parse_helper.rb

@@ -7,7 +7,7 @@ module ParseHelper
   require 'parser/macruby'
   require 'parser/rubymotion'
 
-  ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 mac ios)
+  ALL_VERSIONS = %w(1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.0 mac ios)
 
   def setup
     @diagnostics = []
@@ -27,7 +27,7 @@ module ParseHelper
     when '2.5' then parser = Parser::Ruby25.new
     when '2.6' then parser = Parser::Ruby26.new
     when '2.7' then parser = Parser::Ruby27.new
-    when '2.8' then parser = Parser::Ruby28.new
+    when '3.0' then parser = Parser::Ruby30.new
     when 'mac' then parser = Parser::MacRuby.new
     when 'ios' then parser = Parser::RubyMotion.new
     else raise "Unrecognized Ruby version #{version}"
@@ -49,15 +49,17 @@ module ParseHelper
     end
   end
 
-  def assert_source_range(begin_pos, end_pos, range, version, what)
-    assert range.is_a?(Parser::Source::Range),
-           "(#{version}) #{range.inspect}.is_a?(Source::Range) for #{what}"
-
-    assert_equal begin_pos, range.begin_pos,
-                 "(#{version}) begin of #{what}"
-
-    assert_equal end_pos, range.end_pos,
-                 "(#{version}) end of #{what}"
+  def assert_source_range(expect_range, range, version, what)
+    if expect_range == nil
+      # Avoid "Use assert_nil if expecting nil from .... This will fail in Minitest 6.""
+      assert_nil range,
+                   "(#{version}) range of #{what}"
+    else
+      assert range.is_a?(Parser::Source::Range),
+             "(#{version}) #{range.inspect}.is_a?(Source::Range) for #{what}"
+      assert_equal expect_range, range.to_range,
+                   "(#{version}) range of #{what}"
+    end
   end
 
   # Use like this:
@@ -105,7 +107,7 @@ module ParseHelper
     assert_equal ast, parsed_ast,
                  "(#{version}) AST equality"
 
-    parse_source_map_descriptions(source_maps) do |begin_pos, end_pos, map_field, ast_path, line|
+    parse_source_map_descriptions(source_maps) do |range, map_field, ast_path, line|
 
       astlet = traverse_ast(parsed_ast, ast_path)
 
@@ -119,9 +121,9 @@ module ParseHelper
       assert astlet.location.respond_to?(map_field),
              "(#{version}) #{astlet.location.inspect}.respond_to?(#{map_field.inspect}) for:\n#{parsed_ast.inspect}"
 
-      range = astlet.location.send(map_field)
+      found_range = astlet.location.send(map_field)
 
-      assert_source_range(begin_pos, end_pos, range, version, line.inspect)
+      assert_source_range(range, found_range, version, line.inspect)
     end
 
     assert parser.instance_eval { @lexer }.cmdarg.empty?,
@@ -164,18 +166,18 @@ module ParseHelper
       assert_equal arguments, emitted_diagnostic.arguments
       assert_equal message, emitted_diagnostic.message
 
-      parse_source_map_descriptions(source_maps) do |begin_pos, end_pos, map_field, ast_path, line|
+      parse_source_map_descriptions(source_maps) do |range, map_field, ast_path, line|
 
         case map_field
         when 'location'
-          assert_source_range begin_pos, end_pos,
+          assert_source_range range,
                               emitted_diagnostic.location,
                               version, 'location'
 
         when 'highlights'
           index = ast_path.first.to_i
 
-          assert_source_range begin_pos, end_pos,
+          assert_source_range range,
                               emitted_diagnostic.highlights[index],
                               version, "#{index}th highlight"
 
@@ -254,7 +256,7 @@ module ParseHelper
   SOURCE_MAP_DESCRIPTION_RE =
       /(?x)
        ^(?# $1 skip)            ^(\s*)
-        (?# $2 highlight)        ([~\^]+)
+        (?# $2 highlight)        ([~\^]+|\!)
                                  \s+
         (?# $3 source_map_field) ([a-z_]+)
         (?# $5 ast_path)         (\s+\(([a-z_.\/0-9]+)\))?
@@ -272,8 +274,11 @@ module ParseHelper
       next if line.empty?
 
       if (match = SOURCE_MAP_DESCRIPTION_RE.match(line))
-        begin_pos        = match[1].length
-        end_pos          = begin_pos + match[2].length
+        if match[2] != '!'
+          begin_pos        = match[1].length
+          end_pos          = begin_pos + match[2].length
+          range            = begin_pos...end_pos
+        end
         source_map_field = match[3]
 
         if match[5]
@@ -282,7 +287,7 @@ module ParseHelper
           ast_path = []
         end
 
-        yield begin_pos, end_pos, source_map_field, ast_path, line
+        yield range, source_map_field, ast_path, line
       else
         raise "Cannot parse source map description line: #{line.inspect}."
       end

data/test/test_current.rb

@@ -22,8 +22,8 @@ class TestCurrent < Minitest::Test
       assert_equal Parser::Ruby26, Parser::CurrentRuby
     when /^2\.7\.\d+/
       assert_equal Parser::Ruby27, Parser::CurrentRuby
-    when /^2\.8\.\d+/
-      assert_equal Parser::Ruby28, Parser::CurrentRuby
+    when /^3\.0\.\d+/
+      assert_equal Parser::Ruby30, Parser::CurrentRuby
     else
       flunk "Update test_current for #{RUBY_VERSION}"
     end

data/test/test_lexer.rb

@@ -3568,7 +3568,7 @@ class TestLexer < Minitest::Test
   end
 
   def test_endless_method
-    setup_lexer(28)
+    setup_lexer(30)
 
     assert_scanned('def foo() = 42',
                     :kDEF, "def", [0, 3],

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,7 +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_2_8 = SINCE_2_7 - %w(2.7)
+  SINCE_3_0 = SINCE_2_7 - %w(2.7)
 
   # Guidelines for test naming:
   #  * Test structure follows structure of AST_FORMAT.md.
@@ -1856,6 +1856,7 @@ class TestParser < Minitest::Test
       %q{def foo; end},
       %q{~~~ keyword
         |    ~~~ name
+        |! assignment
         |         ~~~ end})
 
     assert_parses(
@@ -1976,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
 
@@ -6584,7 +6587,7 @@ class TestParser < Minitest::Test
       %q{def m() = get_context},
       %q{def m(a = get_context) = 42}
     ].each do |code|
-      assert_context([:def], code, SINCE_2_8)
+      assert_context([:def], code, SINCE_3_0)
     end
   end
 
@@ -6600,7 +6603,7 @@ class TestParser < Minitest::Test
       %q{def foo.m() = get_context},
       %q{def foo.m(a = get_context) = 42}
     ].each do |code|
-      assert_context([:defs], code, SINCE_2_8)
+      assert_context([:defs], code, SINCE_3_0)
     end
   end
 
@@ -7511,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' }],
@@ -7539,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
@@ -7894,7 +7897,7 @@ class TestParser < Minitest::Test
       [:error, :unexpected_token, { :token => 'tBDOT3' }],
       %q{def foo(x,y,z); bar(x, y, z, ...); end},
       %q{                             ^^^ location},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_diagnoses(
       [:error, :unexpected_token, { :token => 'tBDOT3' }],
@@ -7918,7 +7921,7 @@ class TestParser < Minitest::Test
       [:error, :unexpected_token, { :token => 'tDOT3' }],
       %q{->(...) {}},
       %q{   ^^^ location},
-      SINCE_2_8)
+      SINCE_3_0)
 
     # Here and below the parser asssumes that
     # it can be a beginningless range, so the error comes after reducing right paren
@@ -7987,7 +7990,7 @@ class TestParser < Minitest::Test
         |       ~~~~~~~~~~~ expression (args)
         |                 ~ end (args)
         |              ~~~ expression (args.forward_arg)},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
 
@@ -8906,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,
@@ -9561,18 +9579,19 @@ class TestParser < Minitest::Test
 
   def test_endless_method
     assert_parses(
-      s(:def_e, :foo,
+      s(:def, :foo,
         s(:args),
         s(:int, 42)),
       %q{def foo() = 42},
       %q{~~~ keyword
         |    ~~~ name
         |          ^ assignment
+        |! end
         |~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:def_e, :inc,
+      s(:def, :inc,
         s(:args, s(:arg, :x)),
         s(:send,
           s(:lvar, :x), :+,
@@ -9582,10 +9601,10 @@ class TestParser < Minitest::Test
         |    ~~~ name
         |           ^ assignment
         |~~~~~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:defs_e, s(:send, nil, :obj), :foo,
+      s(:defs, s(:send, nil, :obj), :foo,
         s(:args),
         s(:int, 42)),
       %q{def obj.foo() = 42},
@@ -9594,10 +9613,10 @@ class TestParser < Minitest::Test
         |        ~~~ name
         |              ^ assignment
         |~~~~~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:defs_e, s(:send, nil, :obj), :inc,
+      s(:defs, s(:send, nil, :obj), :inc,
         s(:args, s(:arg, :x)),
         s(:send,
           s(:lvar, :x), :+,
@@ -9608,13 +9627,13 @@ class TestParser < Minitest::Test
         |       ^ operator
         |               ^ assignment
         |~~~~~~~~~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
   def test_endless_method_forwarded_args_legacy
     Parser::Builders::Default.emit_forward_arg = false
     assert_parses(
-      s(:def_e, :foo,
+      s(:def, :foo,
         s(:forward_args),
         s(:send, nil, :bar,
           s(:forwarded_args))),
@@ -9623,7 +9642,7 @@ class TestParser < Minitest::Test
         |    ~~~ name
         |             ^ assignment
         |~~~~~~~~~~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
     Parser::Builders::Default.emit_forward_arg = true
   end
 
@@ -9632,19 +9651,19 @@ class TestParser < Minitest::Test
       [:error, :unexpected_token, { :token => 'tEQL' }],
       %Q{def foo = 42},
       %q{        ^ location},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_diagnoses(
       [:error, :unexpected_token, { :token => 'tEQL' }],
       %Q{def obj.foo = 42},
       %q{            ^ location},
-      SINCE_2_8
+      SINCE_3_0
     )
   end
 
   def test_endless_method_with_rescue_mod
     assert_parses(
-      s(:def_e, :m,
+      s(:def, :m,
         s(:args),
         s(:rescue,
           s(:int, 1),
@@ -9652,10 +9671,10 @@ class TestParser < Minitest::Test
             s(:int, 2)), nil)),
       %q{def m() = 1 rescue 2},
       %q{},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:defs_e,
+      s(:defs,
         s(:self), :m,
         s(:args),
         s(:rescue,
@@ -9664,48 +9683,48 @@ class TestParser < Minitest::Test
             s(:int, 2)), nil)),
       %q{def self.m() = 1 rescue 2},
       %q{},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
   def test_rasgn
     assert_parses(
-      s(:rasgn,
-        s(:int, 1), s(:lvasgn, :a)),
+      s(:lvasgn, :a,
+        s(:int, 1)),
       %q{1 => a},
       %q{~~~~~~ expression
         |  ^^ operator},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:rasgn,
-        s(:send, s(:int, 1), :+, s(:int, 2)),
-        s(:gvasgn, :$a)),
+      s(:gvasgn, :$a,
+        s(:send, s(:int, 1), :+, s(:int, 2))),
       %q{1 + 2 => $a},
       %q{~~~~~~~~~~~ expression
         |      ^^ operator},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
   def test_mrasgn
     assert_parses(
-      s(:mrasgn,
-        s(:send, s(:int, 13), :divmod, s(:int, 5)),
-        s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b))),
+      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_2_8)
+      SINCE_3_0)
 
     assert_parses(
-      s(:mrasgn,
-        s(:mrasgn,
-          s(:send, s(:int, 13), :divmod, s(:int, 5)),
-          s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b))),
-        s(:mlhs, s(:lvasgn, :c), s(:lvasgn, :d))),
+      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 (mrasgn)
+      %q{~~~~~~~~~~~~~~~~~~~ expression (masgn)
         |~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
   def test_rasgn_line_continuation
@@ -9713,7 +9732,7 @@ class TestParser < Minitest::Test
       [:error, :unexpected_token, { :token => 'tASSOC' }],
       %Q{13.divmod(5)\n=> a,b; [a, b]},
       %{             ^^ location},
-      SINCE_2_8)
+      SINCE_3_0)
   end
 
   def test_find_pattern
@@ -9735,7 +9754,7 @@ class TestParser < Minitest::Test
         |                  ~ end (in_pattern.find_pattern)
         |    ~~ expression (in_pattern.find_pattern.match_rest/1)
         |                ~~ expression (in_pattern.find_pattern.match_rest/2)},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses_pattern_match(
       s(:in_pattern,
@@ -9749,7 +9768,7 @@ class TestParser < Minitest::Test
         s(:true)),
       %q{in String(*, 1, *) then true},
       %q{          ~~~~~~~ expression (in_pattern.const_pattern.find_pattern)},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses_pattern_match(
       s(:in_pattern,
@@ -9763,7 +9782,7 @@ class TestParser < Minitest::Test
         s(:true)),
       %q{in Array[*, 1, *] then true},
       %q{         ~~~~~~~ expression (in_pattern.const_pattern.find_pattern)},
-      SINCE_2_8)
+      SINCE_3_0)
 
     assert_parses_pattern_match(
       s(:in_pattern,
@@ -9775,6 +9794,193 @@ class TestParser < Minitest::Test
         s(:true)),
       %q{in *, 42, * then true},
       %q{   ~~~~~~~~ expression (in_pattern.find_pattern)},
-      SINCE_2_8)
+      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