ripper_ruby_parser 1.7.0 → 1.9.0

data/test/end_to_end/lib_comparison_test.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  let :newparser do
-    RipperRubyParser::Parser.new
-  end
-
-  let :oldparser do
-    RubyParser.for_current_ruby
-  end
-
-  Dir.glob("lib/**/*.rb").each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      it "gives the same result" do
-        original = oldparser.parse program
-        imitation = newparser.parse program
-
-        _(formatted(imitation)).must_equal formatted(original)
-      end
-    end
-  end
-end

data/test/end_to_end/line_numbering_test.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  describe "for a multi-line program" do
-    let :program do
-      <<-RUBY
-      class Foo
-        def foo()
-          bar()
-          baz(qux)
-        end
-      end
-
-      module Bar
-        @@baz = {}
-      end
-      RUBY
-    end
-
-    it "gives the same result" do
-      _(program).must_be_parsed_as_before
-    end
-
-    it "gives the same result with line numbers" do
-      _(program).must_be_parsed_as_before with_line_numbers: true
-    end
-  end
-end

data/test/end_to_end/samples_comparison_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  Dir.glob(File.expand_path("../samples/*.rb", File.dirname(__FILE__))).each do |file|
-    it "gives the same result for #{file}" do
-      program = File.read file
-      _(program).must_be_parsed_as_before
-    end
-  end
-end

data/test/end_to_end/test_comparison_test.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "ruby_parser"
-
-describe "Using RipperRubyParser and RubyParser" do
-  let :newparser do
-    RipperRubyParser::Parser.new
-  end
-
-  let :oldparser do
-    RubyParser.for_current_ruby
-  end
-
-  Dir.glob("test/ripper_ruby_parser/**/*.rb").each do |file|
-    describe "for #{file}" do
-      let :program do
-        File.read file
-      end
-
-      it "gives the same result" do
-        # Clone string because ruby_parser destroys it when there's a heredoc
-        # inside.
-        copy = program.clone
-        original = oldparser.parse program
-        imitation = newparser.parse copy
-
-        _(formatted(imitation)).must_equal formatted(original)
-      end
-    end
-  end
-end

data/test/pt_testcase/pt_test.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-require "pt_testcase"
-
-class TestParser < RipperRubyParser::Parser
-  def process(input)
-    parse input
-  end
-end
-
-SKIPPED_TESTS = ["dstr_heredoc_windoze_sucks"].freeze
-
-class RubyParserTestCase < ParseTreeTestCase
-  def self.previous(_key)
-    "Ruby"
-  end
-
-  def self.generate_test(klass, node, data, input_name, _output_name)
-    if data["Ruby"].is_a? Array
-      klass.send :define_method, "test_#{node}" do
-        skip "Not a parser test"
-      end
-      return
-    end
-
-    if SKIPPED_TESTS.include? node
-      klass.send :define_method, "test_#{node}" do
-        skip "Can't or won't fix this difference"
-      end
-      return
-    end
-
-    super klass, node, data, input_name, "ParseTree"
-  end
-end
-
-class TestRuby19Parser < RubyParserTestCase
-  def setup
-    super
-
-    self.processor = TestParser.new
-  end
-end

data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-
-describe RipperRubyParser::CommentingRipperParser do
-  def parse_with_builder(str)
-    builder = RipperRubyParser::CommentingRipperParser.new str
-    builder.parse
-  end
-
-  def empty_params_list
-    @empty_params_list ||= s(:params, *([nil] * 7))
-  end
-
-  describe "handling comments" do
-    # Handle different results for dynamic symbol strings. This was changed in
-    # Ruby 2.6.3 and up. See https://bugs.ruby-lang.org/issues/15670
-    let(:dsym_string_type) { RUBY_VERSION < "2.6.3" ? :xstring : :string_content }
-
-    it "produces a comment node surrounding a commented def" do
-      result = parse_with_builder "# Foo\ndef foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:def,
-                                   s(:@ident, "foo", s(2, 4)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 12))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produces a blank comment node surrounding a def that has no comment" do
-      result = parse_with_builder "def foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "foo", s(1, 4)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 12))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "produces a comment node surrounding a commented class" do
-      result = parse_with_builder "# Foo\nclass Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(2, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 10))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produce a blank comment node surrounding a class that has no comment" do
-      result = parse_with_builder "class Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(1, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 10))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "produces a comment node surrounding a commented module" do
-      result = parse_with_builder "# Foo\nmodule Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "# Foo\n",
-                                 s(:module,
-                                   s(:const_ref, s(:@const, "Foo", s(2, 7))),
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(2, 11))), nil, nil, nil),
-                                   s(2, 0)))))
-    end
-
-    it "produces a blank comment node surrounding a module that has no comment" do
-      result = parse_with_builder "module Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "",
-                                 s(:module,
-                                   s(:const_ref, s(:@const, "Foo", s(1, 7))),
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 11))), nil, nil, nil),
-                                   s(1, 0)))))
-    end
-
-    it "is not confused by a symbol containing a keyword" do
-      result = parse_with_builder ":class; def foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:symbol_literal, s(:symbol, s(:@kw, "class", s(1, 1)))),
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "foo", s(1, 12)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                   s(1, 8)))))
-    end
-
-    it "is not confused by a dynamic symbol" do
-      result = parse_with_builder ":'foo'; def bar; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:dyna_symbol,
-                                 s(dsym_string_type,
-                                   s(:@tstring_content, "foo", s(1, 2), ":'"))),
-                               s(:comment,
-                                 "",
-                                 s(:def,
-                                   s(:@ident, "bar", s(1, 12)),
-                                   empty_params_list,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(1, 20))), nil, nil, nil),
-                                   s(1, 8)))))
-    end
-
-    it "is not confused by a dynamic symbol containing a class definition" do
-      result = parse_with_builder ":\"foo\#{class Bar;end}\""
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:dyna_symbol,
-                                 s(dsym_string_type,
-                                   s(:@tstring_content, "foo", s(1, 2), ':"'),
-                                   s(:string_embexpr,
-                                     s(:stmts,
-                                       s(:comment,
-                                         "",
-                                         s(:class,
-                                           s(:const_ref, s(:@const, "Bar", s(1, 13))),
-                                           nil,
-                                           s(:bodystmt,
-                                             s(:stmts, s(:void_stmt, s(1, 17))),
-                                             nil, nil, nil),
-                                           s(1, 7)))))))))
-    end
-
-    it "turns an embedded document into a comment node" do
-      result = parse_with_builder "=begin Hello\nthere\n=end\nclass Foo; end"
-      _(result).must_equal s(:program,
-                             s(:stmts,
-                               s(:comment,
-                                 "=begin Hello\nthere\n=end\n",
-                                 s(:class,
-                                   s(:const_ref, s(:@const, "Foo", s(4, 6))),
-                                   nil,
-                                   s(:bodystmt,
-                                     s(:stmts, s(:void_stmt, s(4, 10))), nil, nil, nil),
-                                   s(4, 0)))))
-    end
-  end
-
-  describe "handling syntax errors" do
-    it "raises an error for an incomplete source" do
-      _(proc { parse_with_builder "def foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error for an invalid class name" do
-      _(proc { parse_with_builder "class foo; end" })
-        .must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing $1 as foo" do
-      _(proc { parse_with_builder "alias foo $1" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing foo as $1" do
-      _(proc { parse_with_builder "alias $1 foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error aliasing $2 as $1" do
-      _(proc { parse_with_builder "alias $1 $2" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error assigning to $1" do
-      _(proc { parse_with_builder "$1 = foo" }).must_raise RipperRubyParser::SyntaxError
-    end
-
-    it "raises an error using an invalid parameter name" do
-      _(proc { parse_with_builder "def foo(BAR); end" })
-        .must_raise RipperRubyParser::SyntaxError
-    end
-  end
-end

data/test/ripper_ruby_parser/parser_test.rb

@@ -1,553 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path("../test_helper.rb", File.dirname(__FILE__))
-
-describe RipperRubyParser::Parser do
-  let(:parser) { RipperRubyParser::Parser.new }
-  describe "#parse" do
-    it "returns an s-expression" do
-      result = parser.parse "foo"
-      _(result).must_be_instance_of Sexp
-    end
-
-    describe "for an empty program" do
-      it "returns nil" do
-        _("").must_be_parsed_as nil
-      end
-    end
-
-    describe "for a class declaration" do
-      it "works with a namespaced class name" do
-        _("class Foo::Bar; end")
-          .must_be_parsed_as s(:class,
-                               s(:colon2, s(:const, :Foo), :Bar),
-                               nil)
-      end
-
-      it "works for singleton classes" do
-        _("class << self; end").must_be_parsed_as s(:sclass, s(:self))
-      end
-    end
-
-    describe "for a module declaration" do
-      it "works with a simple module name" do
-        _("module Foo; end")
-          .must_be_parsed_as s(:module, :Foo)
-      end
-
-      it "works with a namespaced module name" do
-        _("module Foo::Bar; end")
-          .must_be_parsed_as s(:module,
-                               s(:colon2, s(:const, :Foo), :Bar))
-      end
-    end
-
-    describe "for empty parentheses" do
-      it "works with lone ()" do
-        _("()").must_be_parsed_as s(:nil)
-      end
-    end
-
-    describe "for a begin..end block" do
-      it "works with no statements" do
-        _("begin; end")
-          .must_be_parsed_as s(:nil)
-      end
-
-      it "works with one statement" do
-        _("begin; foo; end")
-          .must_be_parsed_as s(:call, nil, :foo)
-      end
-
-      it "works with multiple statements" do
-        _("begin; foo; bar; end")
-          .must_be_parsed_as s(:block,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-    end
-
-    describe "for arguments" do
-      it "works for a simple case with splat" do
-        _("foo *bar")
-          .must_be_parsed_as s(:call,
-                               nil,
-                               :foo,
-                               s(:splat, s(:call, nil, :bar)))
-      end
-
-      it "works for a multi-argument case with splat" do
-        _("foo bar, *baz")
-          .must_be_parsed_as s(:call,
-                               nil,
-                               :foo,
-                               s(:call, nil, :bar),
-                               s(:splat, s(:call, nil, :baz)))
-      end
-
-      it "works for a simple case passing a block" do
-        _("foo &bar")
-          .must_be_parsed_as s(:call, nil, :foo,
-                               s(:block_pass,
-                                 s(:call, nil, :bar)))
-      end
-
-      it "works for a bare hash" do
-        _("foo bar => baz")
-          .must_be_parsed_as s(:call, nil, :foo,
-                               s(:hash,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-    end
-
-    describe "for the __ENCODING__ keyword" do
-      it "evaluates to the equivalent of Encoding::UTF_8" do
-        _("__ENCODING__")
-          .must_be_parsed_as s(:colon2, s(:const, :Encoding), :UTF_8)
-      end
-    end
-
-    describe "for the __FILE__ keyword" do
-      describe "when not passing a file name" do
-        it "creates a string sexp with value '(string)'" do
-          _("__FILE__")
-            .must_be_parsed_as s(:str, "(string)")
-        end
-      end
-
-      describe "when passing a file name" do
-        it "creates a string sexp with the file name" do
-          result = parser.parse "__FILE__", "foo"
-          _(result).must_equal s(:str, "foo")
-        end
-      end
-    end
-
-    describe "for the __LINE__ keyword" do
-      it "creates a literal sexp with value of the line number" do
-        _("__LINE__")
-          .must_be_parsed_as s(:lit, 1)
-        _("\n__LINE__")
-          .must_be_parsed_as s(:lit, 2)
-      end
-    end
-
-    describe "for the END keyword" do
-      it "converts to a :postexe iterator" do
-        _("END { foo }")
-          .must_be_parsed_as s(:iter, s(:postexe), 0, s(:call, nil, :foo))
-      end
-
-      it "works with an empty block" do
-        _("END { }")
-          .must_be_parsed_as s(:iter, s(:postexe), 0)
-      end
-
-      it "assigns correct line numbers" do
-        _("END {\nfoo\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:postexe).line(1), 0,
-                               s(:call, nil, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "assigns correct line numbers to a embedded begin block" do
-        _("END {\nbegin\nfoo\nend\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:postexe).line(1), 0,
-                               s(:call, nil, :foo).line(3)).line(1),
-                             with_line_numbers: true
-      end
-    end
-
-    describe "for the BEGIN keyword" do
-      it "converts to a :preexe iterator" do
-        _("BEGIN { foo }")
-          .must_be_parsed_as s(:iter, s(:preexe), 0, s(:call, nil, :foo))
-      end
-
-      it "works with an empty block" do
-        _("BEGIN { }")
-          .must_be_parsed_as s(:iter, s(:preexe), 0)
-      end
-
-      it "assigns correct line numbers" do
-        _("BEGIN {\nfoo\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:preexe).line(1), 0,
-                               s(:call, nil, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "assigns correct line numbers to a embedded begin block" do
-        _("BEGIN {\nbegin\nfoo\nend\n}")
-          .must_be_parsed_as s(:iter,
-                               s(:preexe).line(1), 0,
-                               s(:begin,
-                                 s(:call, nil, :foo).line(3)).line(2)).line(1),
-                             with_line_numbers: true
-      end
-    end
-
-    describe "for constant lookups" do
-      it "works when explicitely starting from the root namespace" do
-        _("::Foo")
-          .must_be_parsed_as s(:colon3, :Foo)
-      end
-
-      it "works with a three-level constant lookup" do
-        _("Foo::Bar::Baz")
-          .must_be_parsed_as s(:colon2,
-                               s(:colon2, s(:const, :Foo), :Bar),
-                               :Baz)
-      end
-
-      it "works looking up a constant in a non-constant" do
-        _("foo::Bar").must_be_parsed_as s(:colon2,
-                                          s(:call, nil, :foo),
-                                          :Bar)
-      end
-    end
-
-    describe "for variable references" do
-      it "works for self" do
-        _("self")
-          .must_be_parsed_as s(:self)
-      end
-
-      it "works for instance variables" do
-        _("@foo")
-          .must_be_parsed_as s(:ivar, :@foo)
-      end
-
-      it "works for global variables" do
-        _("$foo")
-          .must_be_parsed_as s(:gvar, :$foo)
-      end
-
-      it "works for regexp match references" do
-        _("$1")
-          .must_be_parsed_as s(:nth_ref, 1)
-      end
-
-      specify { _("$'").must_be_parsed_as s(:back_ref, :"'") }
-      specify { _("$&").must_be_parsed_as s(:back_ref, :"&") }
-
-      it "works for class variables" do
-        _("@@foo")
-          .must_be_parsed_as s(:cvar, :@@foo)
-      end
-    end
-
-    describe "for expressions" do
-      it "handles assignment inside binary operator expressions" do
-        _("foo + (bar = baz)")
-          .must_be_parsed_as s(:call,
-                               s(:call, nil, :foo),
-                               :+,
-                               s(:lasgn,
-                                 :bar,
-                                 s(:call, nil, :baz)))
-      end
-
-      it "handles assignment inside unary operator expressions" do
-        _("+(foo = bar)")
-          .must_be_parsed_as s(:call,
-                               s(:lasgn, :foo, s(:call, nil, :bar)),
-                               :+@)
-      end
-    end
-
-    # Note: differences in the handling of comments are not caught by Sexp's
-    # implementation of equality.
-    describe "for comments" do
-      it "handles method comments" do
-        result = parser.parse "# Foo\ndef foo; end"
-        _(result).must_equal s(:defn,
-                               :foo,
-                               s(:args), s(:nil))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      it "handles comments for methods with explicit receiver" do
-        result = parser.parse "# Foo\ndef foo.bar; end"
-        _(result).must_equal s(:defs,
-                               s(:call, nil, :foo),
-                               :bar,
-                               s(:args),
-                               s(:nil))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      it "matches comments to the correct entity" do
-        result = parser.parse "# Foo\nclass Foo\n# Bar\ndef bar\nend\nend"
-        _(result).must_equal s(:class, :Foo, nil,
-                               s(:defn, :bar,
-                                 s(:args), s(:nil)))
-        _(result.comments).must_equal "# Foo\n"
-        defn = result[3]
-        _(defn.sexp_type).must_equal :defn
-        _(defn.comments).must_equal "# Bar\n"
-      end
-
-      it "combines multi-line comments" do
-        result = parser.parse "# Foo\n# Bar\ndef foo; end"
-        _(result).must_equal s(:defn,
-                               :foo,
-                               s(:args), s(:nil))
-        _(result.comments).must_equal "# Foo\n# Bar\n"
-      end
-
-      it "drops comments inside method bodies" do
-        result = parser.parse <<-RUBY
-          # Foo
-          class Foo
-            # foo
-            def foo
-              bar # this is dropped
-            end
-
-            # bar
-            def bar
-              baz
-            end
-          end
-        RUBY
-        _(result).must_equal s(:class,
-                               :Foo,
-                               nil,
-                               s(:defn, :foo, s(:args), s(:call, nil, :bar)),
-                               s(:defn, :bar, s(:args), s(:call, nil, :baz)))
-        _(result.comments).must_equal "# Foo\n"
-        _(result[3].comments).must_equal "# foo\n"
-        _(result[4].comments).must_equal "# bar\n"
-      end
-
-      it "handles use of singleton class inside methods" do
-        result = parser.parse "# Foo\ndef bar\nclass << self\nbaz\nend\nend"
-        _(result).must_equal s(:defn,
-                               :bar,
-                               s(:args),
-                               s(:sclass, s(:self),
-                                 s(:call, nil, :baz)))
-        _(result.comments).must_equal "# Foo\n"
-      end
-
-      # TODO: Prefer assigning comment to the BEGIN instead
-      it "assigns comments on BEGIN blocks to the following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Foo\nclass Bar\n# foo\ndef foo; end\nend"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:class, :Bar, nil,
-                                 s(:defn, :foo, s(:args), s(:nil))))
-        _(result[2].comments).must_equal "# Bar\n# Foo\n"
-        _(result[2][3].comments).must_equal "# foo\n"
-      end
-
-      it "assigns comments on multiple BEGIN blocks to the following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Baz\nBEGIN { }\n# Foo\ndef foo; end"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:iter, s(:preexe), 0),
-                               s(:defn, :foo, s(:args), s(:nil)))
-        _(result[3].comments).must_equal "# Bar\n# Baz\n# Foo\n"
-      end
-
-      it "assigns comments on BEGIN blocks to the first following item" do
-        result = parser.parse "# Bar\nBEGIN { }\n# Baz\nBEGIN { }\n# Foo\ndef foo; end"
-        _(result).must_equal s(:block,
-                               s(:iter, s(:preexe), 0),
-                               s(:iter, s(:preexe), 0),
-                               s(:defn, :foo, s(:args), s(:nil)))
-        _(result[3].comments).must_equal "# Bar\n# Baz\n# Foo\n"
-      end
-    end
-
-    # Note: differences in the handling of line numbers are not caught by
-    # Sexp's implementation of equality.
-    describe "assigning line numbers" do
-      it "works for a plain method call" do
-        result = parser.parse "foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with parentheses" do
-        result = parser.parse "foo()"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with receiver" do
-        result = parser.parse "foo.bar"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with receiver and arguments" do
-        result = parser.parse "foo.bar baz"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method call with arguments" do
-        result = parser.parse "foo bar"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a block with two lines" do
-        result = parser.parse "foo\nbar\n"
-        _(result.sexp_type).must_equal :block
-        _(result[1].line).must_equal 1
-        _(result[2].line).must_equal 2
-        _(result.line).must_equal 1
-      end
-
-      it "works for a constant reference" do
-        result = parser.parse "Foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for an instance variable" do
-        result = parser.parse "@foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a global variable" do
-        result = parser.parse "$foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a class variable" do
-        result = parser.parse "@@foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a local variable" do
-        _("foo = bar\nfoo\n")
-          .must_be_parsed_as s(:block,
-                               s(:lasgn, :foo, s(:call, nil, :bar).line(1)).line(1),
-                               s(:lvar, :foo).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      it "works for an integer literal" do
-        result = parser.parse "42"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a float literal" do
-        result = parser.parse "3.14"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a range literal" do
-        result = parser.parse "0..4"
-        _(result.line).must_equal 1
-      end
-
-      it "works for an exclusive range literal" do
-        result = parser.parse "0...4"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a symbol literal" do
-        result = parser.parse ":foo"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a keyword-like symbol literal" do
-        result = parser.parse ":and"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a string literal" do
-        result = parser.parse '"foo"'
-        _(result.line).must_equal 1
-      end
-
-      it "works for a backtick string literal" do
-        result = parser.parse "`foo`"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a plain regexp literal" do
-        result = parser.parse "/foo/"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a regular expression back reference" do
-        result = parser.parse "$1"
-        _(result.line).must_equal 1
-      end
-
-      it "works for self" do
-        result = parser.parse "self"
-        _(result.line).must_equal 1
-      end
-
-      it "works for __FILE__" do
-        result = parser.parse "__FILE__"
-        _(result.line).must_equal 1
-      end
-
-      it "works for nil" do
-        result = parser.parse "nil"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a class definition" do
-        result = parser.parse "class Foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a module definition" do
-        result = parser.parse "module Foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "works for a method definition" do
-        result = parser.parse "def foo; end"
-        _(result.line).must_equal 1
-      end
-
-      it "assigns line numbers to nested sexps without their own line numbers" do
-        _("foo(bar) do\nnext baz\nend\n")
-          .must_be_parsed_as s(:iter,
-                               s(:call, nil, :foo, s(:call, nil, :bar).line(1)).line(1),
-                               0,
-                               s(:next, s(:call, nil, :baz).line(2)).line(2)).line(1),
-                             with_line_numbers: true
-      end
-
-      describe "when a line number is passed" do
-        it "shifts all line numbers as appropriate" do
-          result = parser.parse "foo\nbar\n", "(string)", 3
-          _(result).must_equal s(:block,
-                                 s(:call, nil, :foo),
-                                 s(:call, nil, :bar))
-          _(result.line).must_equal 3
-          _(result[1].line).must_equal 3
-          _(result[2].line).must_equal 4
-        end
-      end
-    end
-  end
-
-  describe "#trickle_up_line_numbers" do
-    it "works through several nested levels" do
-      inner = s(:foo)
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      outer.line = 42
-      parser.send :trickle_down_line_numbers, outer
-      _(inner.line).must_equal 42
-    end
-  end
-
-  describe "#trickle_down_line_numbers" do
-    it "works through several nested levels" do
-      inner = s(:foo)
-      inner.line = 42
-      outer = s(:bar, s(:baz, s(:qux, inner)))
-      parser.send :trickle_up_line_numbers, outer
-      _(outer.line).must_equal 42
-    end
-  end
-end