parser 2.7.0.4 → 2.7.1.3

data/lib/parser/tree_rewriter.rb

@@ -28,8 +28,7 @@ module Parser
   #     EOF
   #
   #     ast           = Parser::CurrentRuby.parse code
-  #     buffer        = Parser::Source::Buffer.new('(example)')
-  #     buffer.source = code
+  #     buffer        = Parser::Source::Buffer.new('(example)', source: code)
   #     rewriter      = RemoveDo.new
   #
   #     # Rewrite the AST, returns a String with the new form.

data/lib/parser/version.rb

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

data/parser.gemspec

@@ -32,6 +32,7 @@ Gem::Specification.new do |spec|
                           lib/parser/ruby25.rb
                           lib/parser/ruby26.rb
                           lib/parser/ruby27.rb
+                          lib/parser/ruby28.rb
                           lib/parser/macruby.rb
                           lib/parser/rubymotion.rb
                        )
@@ -44,7 +45,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency             'ast',       '~> 2.4.0'
 
   spec.add_development_dependency 'bundler',   '>= 1.15', '< 3.0.0'
-  spec.add_development_dependency 'rake',      '~> 10.0'
+  spec.add_development_dependency 'rake',      '~> 13.0.1'
   spec.add_development_dependency 'racc',      '= 1.4.15'
   spec.add_development_dependency 'cliver',    '~> 0.3.2'
 

data/test/helper.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'tempfile'
-require 'minitest/test'
-
 require 'simplecov'
 
 if ENV.include?('COVERAGE') && SimpleCov.usable?
@@ -20,6 +18,7 @@ if ENV.include?('COVERAGE') && SimpleCov.usable?
       ruby25.y
       ruby26.y
       ruby27.y
+      ruby28.y
     ),
     File.expand_path('../../lib/parser', __FILE__))
 
@@ -27,9 +26,9 @@ if ENV.include?('COVERAGE') && SimpleCov.usable?
   at_exit { RaccCoverage.stop }
 
   SimpleCov.start do
-    self.formatter = SimpleCov::Formatter::MultiFormatter[
-      SimpleCov::Formatter::HTMLFormatter,
-    ]
+    self.formatter = SimpleCov::Formatter::MultiFormatter.new(
+      SimpleCov::Formatter::HTMLFormatter
+    )
 
     add_group 'Grammars' do |source_file|
       source_file.filename =~ %r{\.y$}
@@ -52,9 +51,29 @@ require 'minitest/autorun'
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 require 'parser'
 
+module NodeCollector
+  extend self
+  attr_accessor :callbacks, :nodes
+  self.callbacks = []
+  self.nodes = []
+
+  def check
+    @callbacks.each do |callback|
+      @nodes.each { |node| callback.call(node) }
+    end
+    puts "#{callbacks.size} additional tests on #{nodes.size} nodes ran successfully"
+  end
+
+  Minitest.after_run { check }
+end
+
+def for_each_node(&block)
+  NodeCollector.callbacks << block
+end
+
 class Parser::AST::Node
   def initialize(type, *)
-    raise "Type #{type} missing from Parser::Meta::NODE_TYPES" unless Parser::Meta::NODE_TYPES.include?(type)
+    NodeCollector.nodes << self
     super
   end
 end

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 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 2.8 mac ios)
 
   def setup
     @diagnostics = []
@@ -27,6 +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 'mac' then parser = Parser::MacRuby.new
     when 'ios' then parser = Parser::RubyMotion.new
     else raise "Unrecognized Ruby version #{version}"
@@ -84,8 +85,7 @@ module ParseHelper
   end
 
   def try_parsing(ast, code, parser, source_maps, version)
-    source_file = Parser::Source::Buffer.new('(assert_parses)')
-    source_file.source = code
+    source_file = Parser::Source::Buffer.new('(assert_parses)', source: code)
 
     begin
       parsed_ast = parser.parse(source_file)
@@ -105,8 +105,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 |begin_pos, end_pos, map_field, ast_path, line|
 
       astlet = traverse_ast(parsed_ast, ast_path)
 
@@ -142,8 +141,7 @@ module ParseHelper
   # ~~~
   def assert_diagnoses(diagnostic, code, source_maps='', versions=ALL_VERSIONS)
     with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_diagnoses)')
-      source_file.source = code
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses)', source: code)
 
       begin
         parser = parser.parse(source_file)
@@ -159,15 +157,14 @@ module ParseHelper
 
       level, reason, arguments = diagnostic
       arguments ||= {}
-      message     = Parser::MESSAGES[reason] % arguments
+      message     = Parser::Messages.compile(reason, arguments)
 
       assert_equal level, emitted_diagnostic.level
       assert_equal reason, emitted_diagnostic.reason
       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 |begin_pos, end_pos, map_field, ast_path, line|
 
         case map_field
         when 'location'
@@ -201,8 +198,7 @@ module ParseHelper
   # ~~~
   def assert_diagnoses_many(diagnostics, code, versions=ALL_VERSIONS)
     with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(assert_diagnoses_many)')
-      source_file.source = code
+      source_file = Parser::Source::Buffer.new('(assert_diagnoses_many)', source: code)
 
       begin
         parser = parser.parse(source_file)
@@ -215,7 +211,7 @@ module ParseHelper
       diagnostics.zip(@diagnostics) do |expected_diagnostic, actual_diagnostic|
         level, reason, arguments = expected_diagnostic
         arguments ||= {}
-        message     = Parser::MESSAGES[reason] % arguments
+        message     = Parser::Messages.compile(reason, arguments)
 
         assert_equal level, actual_diagnostic.level
         assert_equal reason, actual_diagnostic.reason
@@ -227,8 +223,7 @@ module ParseHelper
 
   def refute_diagnoses(code, versions=ALL_VERSIONS)
     with_versions(versions) do |version, parser|
-      source_file = Parser::Source::Buffer.new('(refute_diagnoses)')
-      source_file.source = code
+      source_file = Parser::Source::Buffer.new('(refute_diagnoses)', source: code)
 
       begin
         parser = parser.parse(source_file)
@@ -244,8 +239,7 @@ module ParseHelper
 
   def assert_context(context, code, versions=ALL_VERSIONS)
     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)
 
       begin
         parser.parse(source_file)

data/test/test_ast_processor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestASTProcessor < Minitest::Test
+  LEAF_NODES = %i[
+    sym str int float complex rational
+    true false nil self
+    __FILE__ __LINE__ __ENCODING__
+    cbase regopt zsuper
+    match_with_trailing_comma match_nil_pattern
+    forward_args forwarded_args numargs kwnilarg
+    objc_varargs objc_restarg objc_kwarg
+    ident
+  ].freeze
+
+  def setup
+    @traversible = Parser::AST::Processor
+      .instance_methods(false)
+      .map { |mid| mid.to_s.scan(/\Aon_(.*)/) }
+      .flatten
+      .map(&:to_sym)
+
+    @traversible += LEAF_NODES
+  end
+
+  def test_nodes_are_traversible
+    for_each_node do |node|
+      assert_includes @traversible, node.type
+    end
+  end
+end

data/test/test_base.rb

@@ -26,6 +26,6 @@ class TestBase < Minitest::Test
   def test_loc_dup
     ast = Parser::CurrentRuby.parse('1')
     assert_nil ast.loc.dup.node
-    Parser::AST::Node.new(:root, [], :location => ast.loc)
+    Parser::AST::Node.new(:zsuper, [], :location => ast.loc)
   end
 end

data/test/test_current.rb

@@ -22,6 +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
     else
       flunk "Update test_current for #{RUBY_VERSION}"
     end

data/test/test_diagnostic.rb

@@ -4,8 +4,8 @@ require 'helper'
 
 class TestDiagnostic < Minitest::Test
   def setup
-    @buffer = Parser::Source::Buffer.new('(string)')
-    @buffer.source = 'if (this is some bad code + bugs)'
+    @buffer = Parser::Source::Buffer.new('(string)',
+      source: 'if (this is some bad code + bugs)')
 
     @range1 = Parser::Source::Range.new(@buffer, 0, 2) # if
     @range2 = Parser::Source::Range.new(@buffer, 4, 8) # this
@@ -16,7 +16,7 @@ class TestDiagnostic < Minitest::Test
       Parser::Diagnostic.new(:foobar, :escape_eof, {}, @range1)
     end
 
-    assert_match /level/, error.message
+    assert_match(/level/, error.message)
   end
 
   def test_freezes
@@ -50,8 +50,8 @@ class TestDiagnostic < Minitest::Test
   end
 
   def test_multiline_render
-    @buffer = Parser::Source::Buffer.new('(string)')
-    @buffer.source = "abc abc abc\ndef def def\nghi ghi ghi\n"
+    @buffer = Parser::Source::Buffer.new('(string)',
+      source: "abc abc abc\ndef def def\nghi ghi ghi\n")
 
     location = Parser::Source::Range.new(@buffer, 4, 27)
 
@@ -80,8 +80,7 @@ class TestDiagnostic < Minitest::Test
   }
 }
     CODE
-    @buffer = Parser::Source::Buffer.new('(string)')
-    @buffer.source = source
+    @buffer = Parser::Source::Buffer.new('(string)', source: source)
 
     location = Parser::Source::Range.new(@buffer, 33, 34)
     diag = Parser::Diagnostic.new(:error, :unexpected_token, { :token => 'tNL' },

data/test/test_diagnostic_engine.rb

@@ -4,9 +4,6 @@ require 'helper'
 
 class TestDiagnosticEngine < Minitest::Test
   def setup
-    @buffer  = Parser::Source::Buffer.new('(source)')
-    @buffer.source = 'foobar'
-
     @engine = Parser::Diagnostic::Engine.new
 
     @queue  = []
@@ -14,7 +11,7 @@ class TestDiagnosticEngine < Minitest::Test
   end
 
   def test_process_warnings
-    warn = Parser::Diagnostic.new(:warning, :invalid_escape, @buffer, 1..2)
+    warn = Parser::Diagnostic.new(:warning, :invalid_escape, {}, 1..2)
     @engine.process(warn)
 
     assert_equal [warn], @queue
@@ -23,7 +20,7 @@ class TestDiagnosticEngine < Minitest::Test
   def test_ignore_warnings
     @engine.ignore_warnings = true
 
-    warn = Parser::Diagnostic.new(:warning, :invalid_escape, @buffer, 1..2)
+    warn = Parser::Diagnostic.new(:warning, :invalid_escape, {}, 1..2)
     @engine.process(warn)
 
     assert_equal [], @queue
@@ -32,7 +29,7 @@ class TestDiagnosticEngine < Minitest::Test
   def test_all_errors_are_fatal
     @engine.all_errors_are_fatal = true
 
-    error = Parser::Diagnostic.new(:error, :invalid_escape, @buffer, 1..2)
+    error = Parser::Diagnostic.new(:error, :invalid_escape, {}, 1..2)
 
     err = assert_raises Parser::SyntaxError do
       @engine.process(error)
@@ -44,14 +41,14 @@ class TestDiagnosticEngine < Minitest::Test
   end
 
   def test_all_errors_are_collected
-    error = Parser::Diagnostic.new(:error, :invalid_escape, @buffer, 1..2)
+    error = Parser::Diagnostic.new(:error, :invalid_escape, {}, 1..2)
     @engine.process(error)
 
     assert_equal [error], @queue
   end
 
   def test_fatal_error
-    fatal = Parser::Diagnostic.new(:fatal, :invalid_escape, @buffer, 1..2)
+    fatal = Parser::Diagnostic.new(:fatal, :invalid_escape, {}, 1..2)
 
     assert_raises Parser::SyntaxError do
       @engine.process(fatal)

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(28)
+
+    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_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_2_8 = SINCE_2_7 - %w(2.7)
 
   # Guidelines for test naming:
   #  * Test structure follows structure of AST_FORMAT.md.
@@ -5359,8 +5360,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 +5433,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 +5517,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 +5548,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 +5575,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)
@@ -8422,7 +8420,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(
@@ -8468,7 +8466,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(
@@ -8675,6 +8673,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,
@@ -8746,6 +8756,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
@@ -8860,6 +8931,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
@@ -8993,7 +9080,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)
@@ -9009,7 +9096,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)
@@ -9024,7 +9111,7 @@ class TestParser < Minitest::Test
         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)
         |   ~ expression (in_pattern.const_pattern.const)
@@ -9041,7 +9128,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)
@@ -9057,7 +9144,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)
@@ -9072,7 +9159,7 @@ class TestParser < Minitest::Test
         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)
         |    ~~ expression (in_pattern.const_pattern.array_pattern)}
@@ -9137,8 +9224,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),
@@ -9148,7 +9234,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).
@@ -9354,4 +9440,157 @@ class TestParser < Minitest::Test
       %{},
       SINCE_1_9)
   end
+
+  def test_endless_method
+    assert_parses(
+      s(:def_e, :foo,
+        s(:args),
+        s(:int, 42)),
+      %q{def foo() = 42},
+      %q{~~~ keyword
+        |    ~~~ name
+        |          ^ assignment
+        |~~~~~~~~~~~~~~ expression},
+      SINCE_2_8)
+
+    assert_parses(
+      s(:def_e, :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_2_8)
+
+    assert_parses(
+      s(:defs_e, s(:send, nil, :obj), :foo,
+        s(:args),
+        s(:int, 42)),
+      %q{def obj.foo() = 42},
+      %q{~~~ keyword
+        |       ^ operator
+        |        ~~~ name
+        |              ^ assignment
+        |~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_2_8)
+
+    assert_parses(
+      s(:defs_e, 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_2_8)
+
+    assert_parses(
+      s(:def_e, :foo,
+        s(:forward_args),
+        s(:send, nil, :bar,
+          s(:forwarded_args))),
+      %q{def foo(...) = bar(...)},
+      %q{~~~ keyword
+        |    ~~~ name
+        |             ^ assignment
+        |~~~~~~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_2_8)
+  end
+
+  def test_endless_method_without_brackets
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tEQL' }],
+      %Q{def foo = 42},
+      %q{        ^ location},
+      SINCE_2_8)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tEQL' }],
+      %Q{def obj.foo = 42},
+      %q{            ^ location},
+      SINCE_2_8
+    )
+  end
+
+  def test_endless_method_with_rescue_mod
+    assert_parses(
+      s(:def_e, :m,
+        s(:args),
+        s(:rescue,
+          s(:int, 1),
+          s(:resbody, nil, nil,
+            s(:int, 2)), nil)),
+      %q{def m() = 1 rescue 2},
+      %q{},
+      SINCE_2_8)
+
+    assert_parses(
+      s(:defs_e,
+        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_2_8)
+  end
+
+  def test_rasgn
+    assert_parses(
+      s(:rasgn,
+        s(:int, 1), s(:lvasgn, :a)),
+      %q{1 => a},
+      %q{~~~~~~ expression
+        |  ^^ operator},
+      SINCE_2_8)
+
+    assert_parses(
+      s(:rasgn,
+        s(:send, s(:int, 1), :+, s(:int, 2)),
+        s(:gvasgn, :$a)),
+      %q{1 + 2 => $a},
+      %q{~~~~~~~~~~~ expression
+        |      ^^ operator},
+      SINCE_2_8)
+  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))),
+      %q{13.divmod(5) => a,b},
+      %q{~~~~~~~~~~~~~~~~~~~ expression
+        |             ^^ operator},
+      SINCE_2_8)
+
+    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))),
+      %q{13.divmod(5) => a,b => c, d},
+      %q{~~~~~~~~~~~~~~~~~~~ expression (mrasgn)
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression},
+      SINCE_2_8)
+  end
+
+  def test_rasgn_line_continuation
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tASSOC' }],
+      %Q{13.divmod(5)\n=> a,b; [a, b]},
+      %{             ^^ location},
+      SINCE_2_8)
+  end
 end