rubyjobbuilderdsl 0.0.0 → 0.0.1

data/vendor/bundle/ruby/2.1.0/gems/parser-2.2.0.pre.4/test/test_parser.rb

@@ -0,0 +1,4872 @@
+# encoding:utf-8
+
+require 'helper'
+require 'parse_helper'
+
+class TestParser < Minitest::Test
+  include ParseHelper
+
+  def parser_for_ruby_version(version)
+    parser = super
+    parser.diagnostics.all_errors_are_fatal = true
+
+    %w(foo bar baz).each do |metasyntactic_var|
+      parser.static_env.declare(metasyntactic_var)
+    end
+
+    parser
+  end
+
+  # Guidelines for test naming:
+  #  * Test structure follows structure of AST_FORMAT.md.
+  #  * Test names follow node names.
+  #  * Structurally similar sources may be grouped into one test.
+  #  * If, following the guidelines above, names clash, append
+  #    an abbreviated disambiguator. E.g. `test_class` and
+  #    `test_class_super`.
+  #  * When writing a test for a bug, append unabbreviated (but
+  #    concise) bug description. E.g. `test_class_bug_missing_newline`.
+  #  * Do not append Ruby language version to the name.
+  #  * When in doubt, look at existing test names.
+  #
+  # Guidelines for writing assertions:
+  #  * Don't check for structurally same source mapping information
+  #    more than once or twice in the entire file. It clutters the
+  #    source for no reason.
+  #  * Don't forget to check for optional delimiters. `()`, `then`, etc.
+  #  * When in doubt, look at existing assertions.
+
+  #
+  # Literals
+  #
+
+  def test_empty_stmt
+    assert_parses(
+      nil,
+      %q{})
+  end
+
+  def test_nil
+    assert_parses(
+      s(:nil),
+      %q{nil},
+      %q{~~~ expression})
+  end
+
+  def test_nil_expression
+    assert_parses(
+      s(:begin),
+      %q{()},
+      %q{^ begin
+        | ^ end
+        |~~ expression})
+
+    assert_parses(
+      s(:kwbegin),
+      %q{begin end},
+      %q{~~~~~ begin
+        |      ~~~ end
+        |~~~~~~~~~ expression})
+  end
+
+  def test_true
+    assert_parses(
+      s(:true),
+      %q{true},
+      %q{~~~~ expression})
+  end
+
+  def test_false
+    assert_parses(
+      s(:false),
+      %q{false},
+      %q{~~~~~ expression})
+  end
+
+  def test_int
+    assert_parses(
+      s(:int, 42),
+      %q{42},
+      %q{~~ expression})
+
+    assert_parses(
+      s(:int, -42),
+      %q{-42},
+      %q{^ operator
+        |~~~ expression})
+  end
+
+  def test_int___LINE__
+    assert_parses(
+      s(:int, 1),
+      %q{__LINE__},
+      %q{~~~~~~~~ expression})
+  end
+
+  def test_float
+    assert_parses(
+      s(:float, 1.33),
+      %q{1.33},
+      %q{~~~~ expression})
+
+    assert_parses(
+      s(:float, -1.33),
+      %q{-1.33},
+      %q{^ operator
+        |~~~~~ expression})
+  end
+
+  def test_rational
+    assert_parses(
+      s(:rational, Rational(42)),
+      %q{42r},
+      %q{~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses(
+      s(:rational, Rational(421, 10)),
+      %q{42.1r},
+      %q{~~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_complex
+    assert_parses(
+      s(:complex, Complex(0, 42)),
+      %q{42i},
+      %q{~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses(
+      s(:complex, Complex(0, Rational(42))),
+      %q{42ri},
+      %q{~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses(
+      s(:complex, Complex(0, 42.1)),
+      %q{42.1i},
+      %q{~~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses(
+      s(:complex, Complex(0, Rational(421, 10))),
+      %q{42.1ri},
+      %q{~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  # Strings
+
+  def test_string_plain
+    assert_parses(
+      s(:str, 'foobar'),
+      %q{'foobar'},
+      %q{^ begin
+        |       ^ end
+        |~~~~~~~~ expression})
+
+    assert_parses(
+      s(:str, 'foobar'),
+      %q{%q(foobar)},
+      %q{^^^ begin
+        |         ^ end
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_string_interp
+    assert_parses(
+      s(:dstr,
+        s(:str, 'foo'),
+        s(:begin, s(:lvar, :bar)),
+        s(:str, 'baz')),
+      %q{"foo#{bar}baz"},
+      %q{^ begin
+        |             ^ end
+        |    ^^ begin (begin)
+        |         ^ end (begin)
+        |    ~~~~~~ expression (begin)
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_string_dvar
+    assert_parses(
+      s(:dstr,
+        s(:ivar, :@a),
+        s(:str, ' '),
+        s(:cvar, :@@a),
+        s(:str, ' '),
+        s(:gvar, :$a)),
+      %q{"#@a #@@a #$a"})
+  end
+
+  def test_string_concat
+    assert_parses(
+      s(:dstr,
+        s(:dstr,
+          s(:str, 'foo'),
+          s(:ivar, :@a)),
+        s(:str, 'bar')),
+      %q{"foo#@a" "bar"},
+      %q{^ begin (dstr)
+        |       ^ end (dstr)
+        |         ^ begin (str)
+        |             ^ end (str)
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_string___FILE__
+    assert_parses(
+      s(:str, '(assert_parses)'),
+      %q{__FILE__},
+      %q{~~~~~~~~ expression})
+  end
+
+  def test_character
+    assert_parses(
+      s(:str, 'a'),
+      %q{?a},
+      %q{^ begin
+        |~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:int, 97),
+      %q{?a},
+      %q{~~ expression},
+      %w(1.8))
+  end
+
+  def test_heredoc
+    assert_parses(
+      s(:dstr, s(:str, "foo\n"), s(:str, "bar\n")),
+      %Q{<<HERE!foo!bar!HERE}.gsub('!', "\n"),
+      %q{~~~~~~ expression
+        |       ~~~~~~~~ heredoc_body
+        |               ~~~~ heredoc_end})
+
+    assert_parses(
+      s(:dstr, s(:str, "foo\n"), s(:str, "bar\n")),
+      %Q{<<'HERE'!foo!bar!HERE}.gsub('!', "\n"),
+      %q{~~~~~~~~ expression
+        |         ~~~~~~~~ heredoc_body
+        |                 ~~~~ heredoc_end})
+
+    assert_parses(
+      s(:xstr, s(:str, "foo\n"), s(:str, "bar\n")),
+      %Q{<<`HERE`!foo!bar!HERE}.gsub('!', "\n"),
+      %q{~~~~~~~~ expression
+        |         ~~~~~~~~ heredoc_body
+        |                 ~~~~ heredoc_end})
+  end
+
+  # Symbols
+
+  def test_symbol_plain
+    assert_parses(
+      s(:sym, :foo),
+      %q{:foo},
+      %q{~ begin
+        |~~~~ expression})
+
+    assert_parses(
+      s(:sym, :foo),
+      %q{:'foo'},
+      %q{^^ begin
+        |     ^ end
+        |~~~~~~ expression})
+  end
+
+  def test_symbol_interp
+    assert_parses(
+      s(:dsym,
+        s(:str, 'foo'),
+        s(:begin, s(:lvar, :bar)),
+        s(:str, 'baz')),
+      %q{:"foo#{bar}baz"},
+      %q{^^ begin
+        |              ^ end
+        |     ^^ begin (begin)
+        |          ^ end (begin)
+        |     ~~~~~~ expression (begin)
+        |~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_symbol_empty
+    assert_diagnoses(
+      [:error, :empty_symbol],
+      %q{:''},
+      %q{^^^ location},
+      %w(1.8))
+
+    assert_diagnoses(
+      [:error, :empty_symbol],
+      %q{:""},
+      %q{^^^ location},
+      %w(1.8))
+  end
+
+  # Execute-strings
+
+  def test_xstring_plain
+    assert_parses(
+      s(:xstr, s(:str, 'foobar')),
+      %q{`foobar`},
+      %q{^ begin
+        |       ^ end
+        |~~~~~~~~ expression})
+  end
+
+  def test_xstring_interp
+    assert_parses(
+      s(:xstr,
+        s(:str, 'foo'),
+        s(:begin, s(:lvar, :bar)),
+        s(:str, 'baz')),
+      %q{`foo#{bar}baz`},
+      %q{^ begin
+        |             ^ end
+        |    ^^ begin (begin)
+        |         ^ end (begin)
+        |    ~~~~~~ expression (begin)
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  # Regexp
+
+  def test_regex_plain
+    assert_parses(
+      s(:regexp, s(:str, 'source'), s(:regopt, :i, :m)),
+      %q{/source/im},
+      %q{^ begin
+        |       ^ end
+        |        ~~ expression (regopt)
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_regex_interp
+    assert_parses(
+      s(:regexp,
+        s(:str, 'foo'),
+        s(:begin, s(:lvar, :bar)),
+        s(:str, 'baz'),
+        s(:regopt)),
+      %q{/foo#{bar}baz/},
+      %q{^ begin
+        |    ^^ begin (begin)
+        |         ^ end (begin)
+        |    ~~~~~~ expression (begin)
+        |             ^ end
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  # Arrays
+
+  def test_array_plain
+    assert_parses(
+      s(:array, s(:int, 1), s(:int, 2)),
+      %q{[1, 2]},
+      %q{^ begin
+        |     ^ end
+        |~~~~~~ expression})
+  end
+
+  def test_array_splat
+    assert_parses(
+      s(:array,
+        s(:int, 1),
+        s(:splat, s(:lvar, :foo)),
+        s(:int, 2)),
+      %q{[1, *foo, 2]},
+      %q{^ begin
+        |           ^ end
+        |    ^ operator (splat)
+        |    ~~~~ expression (splat)
+        |~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:array,
+        s(:int, 1),
+        s(:splat, s(:lvar, :foo))),
+      %q{[1, *foo]},
+      %q{^ begin
+        |        ^ end
+        |    ^ operator (splat)
+        |    ~~~~ expression (splat)
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:array,
+        s(:splat, s(:lvar, :foo))),
+      %q{[*foo]})
+  end
+
+  def test_array_assocs
+    assert_parses(
+      s(:array,
+        s(:hash, s(:pair, s(:int, 1), s(:int, 2)))),
+      %q{[ 1 => 2 ]},
+      %q{    ~~ operator (hash.pair)
+        |  ~~~~~~ expression (hash.pair)
+        |  ~~~~~~ expression (hash)})
+
+    assert_parses(
+      s(:array,
+        s(:int, 1),
+        s(:hash, s(:pair, s(:int, 2), s(:int, 3)))),
+      %q{[ 1, 2 => 3 ]},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_array_words
+    assert_parses(
+      s(:array, s(:str, 'foo'), s(:str, 'bar')),
+      %q{%w[foo bar]},
+      %q{^^^ begin
+        |          ^ end
+        |   ~~~ expression (str)
+        |~~~~~~~~~~~ expression})
+  end
+
+  def test_array_words_interp
+    assert_parses(
+      s(:array,
+        s(:str, 'foo'),
+        s(:dstr, s(:begin, s(:lvar, :bar)))),
+      %q{%W[foo #{bar}]},
+      %q{^^^ begin
+        |       ^^ begin (dstr.begin)
+        |            ^ end (dstr.begin)
+        |       ~~~~~~ expression (dstr.begin)
+        |             ^ end
+        |   ~~~ expression (str)
+        |         ~~~ expression (dstr.begin.lvar)
+        |~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:array,
+        s(:str, 'foo'),
+        s(:dstr,
+          s(:begin, s(:lvar, :bar)),
+          s(:str, 'foo'),
+          s(:ivar, :@baz))),
+      %q{%W[foo #{bar}foo#@baz]})
+  end
+
+  def test_array_words_empty
+    assert_parses(
+      s(:array),
+      %q{%w[]},
+      %q{^^^ begin
+        |   ^ end
+        |~~~~ expression})
+
+    assert_parses(
+      s(:array),
+      %q{%W()})
+  end
+
+  def test_array_symbols
+    assert_parses(
+      s(:array, s(:sym, :foo), s(:sym, :bar)),
+      %q{%i[foo bar]},
+      %q{^^^ begin
+        |          ^ end
+        |   ~~~ expression (sym)
+        |~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_array_symbols_interp
+    assert_parses(
+      s(:array,
+        s(:sym, :foo),
+        s(:dsym, s(:begin, s(:lvar, :bar)))),
+      %q{%I[foo #{bar}]},
+      %q{^^^ begin
+        |             ^ end
+        |   ~~~ expression (sym)
+        |       ^^ begin (dsym.begin)
+        |            ^ end (dsym.begin)
+        |       ~~~~~~ expression (dsym.begin)
+        |         ~~~ expression (dsym.begin.lvar)
+        |~~~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:array,
+        s(:dsym,
+          s(:str, 'foo'),
+          s(:begin, s(:lvar, :bar)))),
+      %q{%I[foo#{bar}]},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_array_symbols_empty
+    assert_parses(
+      s(:array),
+      %q{%i[]},
+      %q{^^^ begin
+        |   ^ end
+        |~~~~ expression},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:array),
+      %q{%I()},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  # Hashes
+
+  def test_hash_empty
+    assert_parses(
+      s(:hash),
+      %q[{ }],
+      %q{^ begin
+        |  ^ end
+        |~~~ expression})
+  end
+
+  def test_hash_hashrocket
+    assert_parses(
+      s(:hash, s(:pair, s(:int, 1), s(:int, 2))),
+      %q[{ 1 => 2 }],
+      %q{^ begin
+        |         ^ end
+        |    ^^ operator (pair)
+        |  ~~~~~~ expression (pair)
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:hash,
+        s(:pair, s(:int, 1), s(:int, 2)),
+        s(:pair, s(:sym, :foo), s(:str, 'bar'))),
+      %q[{ 1 => 2, :foo => "bar" }])
+  end
+
+  def test_hash_label
+    assert_parses(
+      s(:hash, s(:pair, s(:sym, :foo), s(:int, 2))),
+      %q[{ foo: 2 }],
+      %q{^ begin
+        |         ^ end
+        |     ^ operator (pair)
+        |  ~~~ expression (pair.sym)
+        |  ~~~~~~ expression (pair)
+        |~~~~~~~~~~ expression},
+        ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_hash_kwsplat
+    assert_parses(
+      s(:hash,
+        s(:pair, s(:sym, :foo), s(:int, 2)),
+        s(:kwsplat, s(:lvar, :bar))),
+      %q[{ foo: 2, **bar }],
+      %q{          ^^ operator (kwsplat)
+        |          ~~~~~ expression (kwsplat)},
+        %w(2.0))
+  end
+
+  def test_hash_no_hashrocket
+    assert_parses(
+      s(:hash, s(:pair, s(:int, 1), s(:int, 2))),
+      %q[{ 1, 2 }],
+      %q{^ begin
+        |       ^ end
+        |  ~~~~ expression (pair)
+        |~~~~~~~~ expression},
+      %w(1.8))
+  end
+
+  def test_hash_no_hashrocket_odd
+    assert_diagnoses(
+      [:error, :odd_hash],
+      %q[{ 1, 2, 3 }],
+      %q(        ~ location),
+      %w(1.8))
+  end
+
+  # Range
+
+  def test_range_inclusive
+    assert_parses(
+      s(:irange, s(:int, 1), s(:int, 2)),
+      %q{1..2},
+      %q{ ~~ operator
+        |~~~~ expression})
+  end
+
+  def test_range_exclusive
+    assert_parses(
+      s(:erange, s(:int, 1), s(:int, 2)),
+      %q{1...2},
+      %q{ ~~~ operator
+        |~~~~~ expression})
+  end
+
+  #
+  # Access
+  #
+
+  # Variables and pseudovariables
+
+  def test_self
+    assert_parses(
+      s(:self),
+      %q{self},
+      %q{~~~~ expression})
+  end
+
+  def test_lvar
+    assert_parses(
+      s(:lvar, :foo),
+      %q{foo},
+      %q{~~~ expression})
+  end
+
+  def test_ivar
+    assert_parses(
+      s(:ivar, :@foo),
+      %q{@foo},
+      %q{~~~~ expression})
+  end
+
+  def test_cvar
+    assert_parses(
+      s(:cvar, :@@foo),
+      %q{@@foo},
+      %q{~~~~~ expression})
+  end
+
+  def test_gvar
+    assert_parses(
+      s(:gvar, :$foo),
+      %q{$foo},
+      %q{~~~~ expression})
+  end
+
+  def test_gvar_dash_empty
+    assert_diagnoses(
+      [:fatal, :unexpected, { :character => '$' }],
+      %q{$- },
+      %q{^ location},
+      %w(2.1))
+  end
+
+  def test_back_ref
+    assert_parses(
+      s(:back_ref, :$+),
+      %q{$+},
+      %q{~~ expression})
+  end
+
+  def test_nth_ref
+    assert_parses(
+      s(:nth_ref, 10),
+      %q{$10},
+      %q{~~~ expression})
+  end
+
+  # Constants
+
+  def test_const_toplevel
+    assert_parses(
+      s(:const, s(:cbase), :Foo),
+      %q{::Foo},
+      %q{  ~~~ name
+        |~~ double_colon
+        |~~~~~ expression})
+  end
+
+  def test_const_scoped
+    assert_parses(
+      s(:const, s(:const, nil, :Bar), :Foo),
+      %q{Bar::Foo},
+      %q{     ~~~ name
+        |   ~~ double_colon
+        |~~~~~~~~ expression})
+  end
+
+  def test_const_unscoped
+    assert_parses(
+      s(:const, nil, :Foo),
+      %q{Foo},
+      %q{~~~ name
+        |~~~ expression})
+  end
+
+  def test___ENCODING__
+    assert_parses(
+      s(:const, s(:const, nil, :Encoding), :UTF_8),
+      %q{__ENCODING__},
+      %q{~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  # defined?
+
+  def test_defined
+    assert_parses(
+      s(:defined?, s(:lvar, :foo)),
+      %q{defined? foo},
+      %q{~~~~~~~~ keyword
+        |~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:defined?, s(:lvar, :foo)),
+      %q{defined?(foo)},
+      %q{~~~~~~~~ keyword
+        |        ^ begin
+        |            ^ end
+        |~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:defined?, s(:ivar, :@foo)),
+      %q{defined? @foo})
+  end
+
+  #
+  # Assignment
+  #
+
+  # Variables
+
+  def test_lvasgn
+    assert_parses(
+      s(:begin,
+        s(:lvasgn, :var, s(:int, 10)),
+        s(:lvar, :var)),
+      %q{var = 10; var},
+      %q{~~~ name (lvasgn)
+        |    ^ operator (lvasgn)
+        |~~~~~~~~ expression (lvasgn)
+        })
+  end
+
+  def test_ivasgn
+    assert_parses(
+      s(:ivasgn, :@var, s(:int, 10)),
+      %q{@var = 10},
+      %q{~~~~ name
+        |     ^ operator
+        |~~~~~~~~~ expression
+        })
+  end
+
+  def test_cvasgn
+    assert_parses(
+      s(:cvasgn, :@@var, s(:int, 10)),
+      %q{@@var = 10},
+      %q{~~~~~ name
+        |      ^ operator
+        |~~~~~~~~~~ expression
+        })
+  end
+
+  def test_gvasgn
+    assert_parses(
+      s(:gvasgn, :$var, s(:int, 10)),
+      %q{$var = 10},
+      %q{~~~~ name
+        |     ^ operator
+        |~~~~~~~~~ expression
+        })
+  end
+
+  def test_asgn_cmd
+    assert_parses(
+      s(:lvasgn, :foo, s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo = m foo})
+
+    assert_parses(
+      s(:lvasgn, :foo,
+        s(:lvasgn, :bar,
+          s(:send, nil, :m, s(:lvar, :foo)))),
+      %q{foo = bar = m foo},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_asgn_keyword_invalid
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{nil = foo},
+      %q{~~~ location})
+
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{self = foo},
+      %q{~~~~ location})
+
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{true = foo},
+      %q{~~~~ location})
+
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{false = foo},
+      %q{~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{__FILE__ = foo},
+      %q{~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{__LINE__ = foo},
+      %q{~~~~~~~~ location})
+  end
+
+  def test_asgn_backref_invalid
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$1 = foo},
+      %q{~~ location})
+  end
+
+  # Constants
+
+  def test_casgn_toplevel
+    assert_parses(
+      s(:casgn, s(:cbase), :Foo, s(:int, 10)),
+      %q{::Foo = 10},
+      %q{  ~~~ name
+        |      ^ operator
+        |~~ double_colon
+        |~~~~~~~~~~ expression
+        })
+  end
+
+  def test_casgn_scoped
+    assert_parses(
+      s(:casgn, s(:const, nil, :Bar), :Foo, s(:int, 10)),
+      %q{Bar::Foo = 10},
+      %q{     ~~~ name
+        |         ^ operator
+        |   ~~ double_colon
+        |~~~~~~~~~~~~~ expression
+        })
+  end
+
+  def test_casgn_unscoped
+    assert_parses(
+      s(:casgn, nil, :Foo, s(:int, 10)),
+      %q{Foo = 10},
+      %q{~~~ name
+        |    ^ operator
+        |~~~~~~~~ expression
+        })
+  end
+
+  def test_casgn_invalid
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def f; Foo = 1; end},
+      %q{       ~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def f; Foo::Bar = 1; end},
+      %q{       ~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def f; ::Bar = 1; end},
+      %q{       ~~~~~ location})
+  end
+
+  # Multiple assignment
+
+  def test_masgn
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :foo), s(:lvasgn, :bar)),
+        s(:array, s(:int, 1), s(:int, 2))),
+      %q{foo, bar = 1, 2},
+      %q{         ^ operator
+        |~~~~~~~~ expression (mlhs)
+        |           ~~~~ expression (array)
+        |~~~~~~~~~~~~~~~ expression
+        })
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :foo), s(:lvasgn, :bar)),
+        s(:array, s(:int, 1), s(:int, 2))),
+      %q{(foo, bar) = 1, 2},
+      %q{^ begin (mlhs)
+        |         ^ end (mlhs)
+        |~~~~~~~~~~ expression (mlhs)
+        |~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :foo),
+          s(:lvasgn, :bar),
+          s(:lvasgn, :baz)),
+        s(:array, s(:int, 1), s(:int, 2))),
+      %q{foo, bar, baz = 1, 2})
+  end
+
+  def test_masgn_splat
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:ivasgn, :@foo), s(:cvasgn, :@@bar)),
+        s(:array, s(:splat, s(:lvar, :foo)))),
+      %q{@foo, @@bar = *foo},
+      %q{              ^ operator (array.splat)
+        |              ~~~~ expression (array.splat)
+        })
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+        s(:array, s(:splat, s(:lvar, :foo)), s(:lvar, :bar))),
+      %q{a, b = *foo, bar},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :a), s(:splat, s(:lvasgn, :b))),
+        s(:lvar, :bar)),
+      %q{a, *b = bar})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :a),
+          s(:splat, s(:lvasgn, :b)),
+          s(:lvasgn, :c)),
+        s(:lvar, :bar)),
+      %q{a, *b, c = bar},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:lvasgn, :a), s(:splat)),
+        s(:lvar, :bar)),
+      %q{a, * = bar})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :a),
+          s(:splat),
+          s(:lvasgn, :c)),
+        s(:lvar, :bar)),
+      %q{a, *, c = bar},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:splat, s(:lvasgn, :b))),
+        s(:lvar, :bar)),
+      %q{*b = bar})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:splat, s(:lvasgn, :b)),
+          s(:lvasgn, :c)),
+        s(:lvar, :bar)),
+      %q{*b, c = bar},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs, s(:splat)),
+        s(:lvar, :bar)),
+      %q{* = bar})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:splat),
+          s(:lvasgn, :c),
+          s(:lvasgn, :d)),
+        s(:lvar, :bar)),
+      %q{*, c, d = bar},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_masgn_nested
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :a),
+          s(:mlhs,
+            s(:lvasgn, :b),
+            s(:lvasgn, :c))),
+        s(:lvar, :foo)),
+      %q{a, (b, c) = foo},
+      %q{   ^ begin (mlhs.mlhs)
+        |        ^ end (mlhs.mlhs)
+        |   ~~~~~~ expression (mlhs.mlhs)
+        })
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :b)),
+        s(:lvar, :foo)),
+      %q{((b, )) = foo},
+      %q{^ begin (mlhs)
+        |      ^ end (mlhs)})
+  end
+
+  def test_masgn_attr
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:send, s(:self), :a=),
+          s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))),
+        s(:lvar, :foo)),
+      %q{self.a, self[1, 2] = foo},
+      %q{~~~~~~ expression (mlhs.send/1)
+        |     ~ selector (mlhs.send/1)
+        |            ~~~~~~ selector (mlhs.send/2)
+        |        ~~~~~~~~~~ expression (mlhs.send/2)})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:send, s(:self), :a=),
+          s(:lvasgn, :foo)),
+        s(:lvar, :foo)),
+      %q{self::a, foo = foo})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:send, s(:self), :A=),
+          s(:lvasgn, :foo)),
+        s(:lvar, :foo)),
+      %q{self.A, foo = foo})
+  end
+
+  def test_masgn_const
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:casgn, s(:self), :A),
+          s(:lvasgn, :foo)),
+        s(:lvar, :foo)),
+      %q{self::A, foo = foo})
+
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:casgn, s(:cbase), :A),
+          s(:lvasgn, :foo)),
+        s(:lvar, :foo)),
+      %q{::A, foo = foo})
+  end
+
+  def test_masgn_cmd
+    assert_parses(
+      s(:masgn,
+        s(:mlhs,
+          s(:lvasgn, :foo),
+          s(:lvasgn, :bar)),
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo, bar = m foo})
+  end
+
+  def test_asgn_mrhs
+    assert_parses(
+      s(:lvasgn, :foo,
+        s(:array, s(:lvar, :bar), s(:int, 1))),
+      %q{foo = bar, 1},
+      %q{      ~~~~~~ expression (array)
+        |~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:lvasgn, :foo,
+        s(:array, s(:splat, s(:lvar, :bar)))),
+      %q{foo = *bar})
+
+    assert_parses(
+      s(:lvasgn, :foo,
+        s(:array,
+          s(:lvar, :baz),
+          s(:splat, s(:lvar, :bar)))),
+      %q{foo = baz, *bar})
+  end
+
+  def test_masgn_keyword_invalid
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{nil, foo = bar},
+      %q{~~~ location})
+  end
+
+  def test_masgn_backref_invalid
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$1, = foo},
+      %q{~~ location})
+  end
+
+  def test_masgn_const_invalid
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def f; self::A, foo = foo; end},
+      %q{       ~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def f; ::A, foo = foo; end},
+      %q{       ~~~ location})
+  end
+
+  # Variable binary operator-assignment
+
+  def test_var_op_asgn
+    assert_parses(
+      s(:op_asgn, s(:lvasgn, :a), :+, s(:int, 1)),
+      %q{a += 1},
+      %q{  ^^ operator
+        |~~~~~~ expression})
+
+    assert_parses(
+      s(:op_asgn, s(:ivasgn, :@a), :|, s(:int, 1)),
+      %q{@a |= 1},
+      %q{   ^^ operator
+        |~~~~~~~ expression})
+
+    assert_parses(
+      s(:op_asgn, s(:cvasgn, :@@var), :|, s(:int, 10)),
+      %q{@@var |= 10})
+
+    assert_parses(
+      s(:def, :a, s(:args),
+        s(:op_asgn, s(:cvasgn, :@@var), :|, s(:int, 10))),
+      %q{def a; @@var |= 10; end})
+  end
+
+  def test_var_op_asgn_cmd
+    assert_parses(
+      s(:op_asgn,
+        s(:lvasgn, :foo), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo += m foo})
+  end
+
+  def test_var_op_asgn_keyword_invalid
+    assert_diagnoses(
+      [:error, :invalid_assignment],
+      %q{nil += foo},
+      %q{~~~ location})
+  end
+
+  def test_const_op_asgn
+    assert_parses(
+      s(:op_asgn,
+        s(:casgn, nil, :A), :+,
+        s(:int, 1)),
+      %q{A += 1})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:casgn, s(:cbase), :A), :+,
+        s(:int, 1)),
+      %q{::A += 1},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:op_asgn,
+        s(:casgn, s(:const, nil, :B), :A), :+,
+        s(:int, 1)),
+      %q{B::A += 1},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:def, :x, s(:args),
+        s(:or_asgn,
+          s(:casgn, s(:self), :A),
+          s(:int, 1))),
+      %q{def x; self::A ||= 1; end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:def, :x, s(:args),
+        s(:or_asgn,
+          s(:casgn, s(:cbase), :A),
+          s(:int, 1))),
+      %q{def x; ::A ||= 1; end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_const_op_asgn_invalid
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{Foo::Bar += 1},
+      %q{     ~~~ location},
+      %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{::Bar += 1},
+      %q{  ~~~ location},
+      %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def foo; Foo::Bar += 1; end},
+      %q{              ~~~ location},
+      %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def foo; ::Bar += 1; end},
+      %q{           ~~~ location},
+      %w(1.8 1.9))
+  end
+
+  # Method binary operator-assignment
+
+  def test_op_asgn
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :a), :+,
+        s(:int, 1)),
+      %q{foo.a += 1},
+      %q{      ^^ operator
+        |    ~ selector (send)
+        |~~~~~ expression (send)
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :a), :+,
+        s(:int, 1)),
+      %q{foo::a += 1})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :A), :+,
+        s(:int, 1)),
+      %q{foo.A += 1})
+  end
+
+  def test_op_asgn_cmd
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :a), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo.a += m foo})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :a), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo::a += m foo})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :A), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo.A += m foo})
+
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :A), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo::A += m foo},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_op_asgn_index
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :[],
+          s(:int, 0), s(:int, 1)), :+,
+        s(:int, 2)),
+      %q{foo[0, 1] += 2},
+      %q{          ^^ operator
+        |   ~~~~~~ selector (send)
+        |~~~~~~~~~ expression (send)
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_op_asgn_index_cmd
+    assert_parses(
+      s(:op_asgn,
+        s(:send, s(:lvar, :foo), :[],
+          s(:int, 0), s(:int, 1)), :+,
+        s(:send, nil, :m, s(:lvar, :foo))),
+      %q{foo[0, 1] += m foo})
+  end
+
+  def test_op_asgn_invalid
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$1 |= 1},
+      %q{~~ location})
+
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$+ |= 1},
+      %q{~~ location})
+
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$+ |= m foo},
+      %q{~~ location})
+  end
+
+  # Variable logical operator-assignment
+
+  def test_var_or_asgn
+    assert_parses(
+      s(:or_asgn, s(:lvasgn, :a), s(:int, 1)),
+      %q{a ||= 1},
+      %q{  ^^^ operator
+        |~~~~~~~ expression})
+  end
+
+  def test_var_and_asgn
+    assert_parses(
+      s(:and_asgn, s(:lvasgn, :a), s(:int, 1)),
+      %q{a &&= 1},
+      %q{  ^^^ operator
+        |~~~~~~~ expression})
+  end
+
+  # Method logical operator-assignment
+
+  def test_or_asgn
+    assert_parses(
+      s(:or_asgn,
+        s(:send, s(:lvar, :foo), :a),
+        s(:int, 1)),
+      %q{foo.a ||= 1},
+      %q{      ^^^ operator
+        |    ~ selector (send)
+        |~~~~~ expression (send)
+        |~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:or_asgn,
+        s(:send, s(:lvar, :foo), :[],
+          s(:int, 0), s(:int, 1)),
+        s(:int, 2)),
+      %q{foo[0, 1] ||= 2},
+      %q{          ^^^ operator
+        |   ~~~~~~ selector (send)
+        |~~~~~~~~~ expression (send)
+        |~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_and_asgn
+    assert_parses(
+      s(:and_asgn,
+        s(:send, s(:lvar, :foo), :a),
+        s(:int, 1)),
+      %q{foo.a &&= 1},
+      %q{      ^^^ operator
+        |    ~ selector (send)
+        |~~~~~ expression (send)
+        |~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:and_asgn,
+        s(:send, s(:lvar, :foo), :[],
+          s(:int, 0), s(:int, 1)),
+        s(:int, 2)),
+      %q{foo[0, 1] &&= 2},
+      %q{          ^^^ operator
+        |   ~~~~~~ selector (send)
+        |~~~~~~~~~ expression (send)
+        |~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_log_asgn_invalid
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$1 &&= 1},
+      %q{~~ location})
+
+    assert_diagnoses(
+      [:error, :backref_assignment],
+      %q{$+ ||= 1},
+      %q{~~ location})
+  end
+
+
+  #
+  # Class and module definitions
+  #
+
+  def test_module
+    assert_parses(
+      s(:module,
+        s(:const, nil, :Foo),
+        nil),
+      %q{module Foo; end},
+      %q{~~~~~~ keyword
+        |       ~~~ name
+        |            ~~~ end})
+  end
+
+  def test_module_invalid
+    assert_diagnoses(
+      [:error, :module_in_def],
+      %q{def a; module Foo; end; end},
+      %q{       ^^^^^^ location})
+  end
+
+  def test_cpath
+    assert_parses(
+      s(:module,
+        s(:const, s(:cbase), :Foo),
+        nil),
+      %q{module ::Foo; end})
+
+    assert_parses(
+      s(:module,
+        s(:const, s(:const, nil, :Bar), :Foo),
+        nil),
+      %q{module Bar::Foo; end})
+  end
+
+  def test_cpath_invalid
+    assert_diagnoses(
+      [:error, :module_name_const],
+      %q{module foo; end})
+  end
+
+  def test_class
+    assert_parses(
+      s(:class,
+        s(:const, nil, :Foo),
+        nil,
+        nil),
+      %q{class Foo; end},
+      %q{~~~~~ keyword
+        |      ~~~ name
+        |           ~~~ end})
+  end
+
+  def test_class_super
+    assert_parses(
+      s(:class,
+        s(:const, nil, :Foo),
+        s(:const, nil, :Bar),
+        nil),
+      %q{class Foo < Bar; end},
+      %q{~~~~~ keyword
+        |          ^ operator
+        |                 ~~~ end})
+  end
+
+  def test_class_super_label
+    assert_parses(
+      s(:class,
+        s(:const, nil, :Foo),
+        s(:send, nil, :a,
+          s(:sym, :b)),
+        nil),
+      %q{class Foo < a:b; end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_class_invalid
+    assert_diagnoses(
+      [:error, :class_in_def],
+      %q{def a; class Foo; end; end},
+      %q{       ^^^^^ location})
+  end
+
+  def test_sclass
+    assert_parses(
+      s(:sclass,
+        s(:lvar, :foo),
+        s(:nil)),
+      %q{class << foo; nil; end},
+      %q{~~~~~ keyword
+        |      ^^ operator
+        |                   ~~~ end})
+  end
+
+  #
+  # Method (un)definition
+  #
+
+  def test_def
+    assert_parses(
+      s(:def, :foo, s(:args), nil),
+      %q{def foo; end},
+      %q{~~~ keyword
+        |    ~~~ name
+        |         ~~~ end})
+
+    assert_parses(
+      s(:def, :String, s(:args), nil),
+      %q{def String; end})
+
+    assert_parses(
+      s(:def, :String=, s(:args), nil),
+      %q{def String=; end})
+
+    assert_parses(
+      s(:def, :until, s(:args), nil),
+      %q{def until; end})
+  end
+
+  def test_defs
+    assert_parses(
+      s(:defs, s(:self), :foo, s(:args), nil),
+      %q{def self.foo; end},
+      %q{~~~ keyword
+        |        ^ operator
+        |         ~~~ name
+        |              ~~~ end})
+
+    assert_parses(
+      s(:defs, s(:self), :foo, s(:args), nil),
+      %q{def self::foo; end},
+      %q{~~~ keyword
+        |        ^^ operator
+        |          ~~~ name
+        |               ~~~ end})
+
+    assert_parses(
+      s(:defs, s(:lvar, :foo), :foo, s(:args), nil),
+      %q{def (foo).foo; end})
+
+    assert_parses(
+      s(:defs, s(:const, nil, :String), :foo,
+        s(:args), nil),
+      %q{def String.foo; end})
+
+    assert_parses(
+      s(:defs, s(:const, nil, :String), :foo,
+        s(:args), nil),
+      %q{def String::foo; end})
+  end
+
+  def test_defs_invalid
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def (1).foo; end},
+      %q{     ~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def ("foo").foo; end},
+      %q{     ~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def ("foo#{bar}").foo; end},
+      %q{     ~~~~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def (:foo).foo; end},
+      %q{     ~~~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def (:"foo#{bar}").foo; end},
+      %q{     ~~~~~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def ([]).foo; end},
+      %q{     ~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def ({}).foo; end},
+      %q{     ~~ location})
+
+    assert_diagnoses(
+      [:error, :singleton_literal],
+      %q{def (/foo/).foo; end},
+      %q{     ~~~~~ location})
+  end
+
+  def test_undef
+    assert_parses(
+      s(:undef,
+        s(:sym, :foo),
+        s(:sym, :bar),
+        s(:dsym, s(:str, 'foo'), s(:begin, s(:int, 1)))),
+      %q{undef foo, :bar, :"foo#{1}"},
+      %q{~~~~~ keyword
+        |      ~~~ expression (sym/1)
+        |           ~~~~ expression (sym/2)
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  #
+  # Aliasing
+  #
+
+  def test_alias
+    assert_parses(
+      s(:alias, s(:sym, :foo), s(:sym, :bar)),
+      %q{alias :foo bar},
+      %q{~~~~~ keyword
+        |      ~~~~ expression (sym/1)
+        |           ~~~ expression (sym/2)
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_alias_gvar
+    assert_parses(
+      s(:alias, s(:gvar, :$a), s(:gvar, :$b)),
+      %q{alias $a $b},
+      %q{      ~~ expression (gvar/1)})
+
+    assert_parses(
+      s(:alias, s(:gvar, :$a), s(:back_ref, :$+)),
+      %q{alias $a $+},
+      %q{         ~~ expression (back_ref)})
+  end
+
+  def test_alias_nth_ref
+    assert_diagnoses(
+      [:error, :nth_ref_alias],
+      %q{alias $a $1},
+      %q{         ~~ location})
+  end
+
+  #
+  # Formal arguments
+  #
+
+  def test_arg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:arg, :foo)),
+        nil),
+      %q{def f(foo); end},
+      %q{      ~~~ name (args.arg)
+        |      ~~~ expression (args.arg)
+        |     ^ begin (args)
+        |         ^ end (args)
+        |     ~~~~~ expression (args)})
+
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:arg, :foo), s(:arg, :bar)),
+        nil),
+      %q{def f(foo, bar); end})
+  end
+
+  def test_optarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:optarg, :foo, s(:int, 1))),
+        nil),
+      %q{def f foo = 1; end},
+      %q{      ~~~ name (args.optarg)
+        |          ^ operator (args.optarg)
+        |      ~~~~~~~ expression (args.optarg)
+        |      ~~~~~~~ expression (args)})
+
+    assert_parses(
+      s(:def, :f,
+        s(:args,
+          s(:optarg, :foo, s(:int, 1)),
+          s(:optarg, :bar, s(:int, 2))),
+        nil),
+      %q{def f(foo=1, bar=2); end})
+  end
+
+  def test_restarg_named
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:restarg, :foo)),
+        nil),
+      %q{def f(*foo); end},
+      %q{       ~~~ name (args.restarg)
+        |      ~~~~ expression (args.restarg)})
+  end
+
+  def test_restarg_unnamed
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:restarg)),
+        nil),
+      %q{def f(*); end},
+      %q{      ~ expression (args.restarg)})
+  end
+
+  def test_kwarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwarg, :foo)),
+        nil),
+      %q{def f(foo:); end},
+      %q{      ~~~ name (args.kwarg)
+        |      ~~~~ expression (args.kwarg)},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_kwoptarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwoptarg, :foo, s(:int, 1))),
+        nil),
+      %q{def f(foo: 1); end},
+      %q{      ~~~ name (args.kwoptarg)
+        |      ~~~~~~ expression (args.kwoptarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_kwrestarg_named
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwrestarg, :foo)),
+        nil),
+      %q{def f(**foo); end},
+      %q{        ~~~ name (args.kwrestarg)
+        |      ~~~~~ expression (args.kwrestarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_kwrestarg_unnamed
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwrestarg)),
+        nil),
+      %q{def f(**); end},
+      %q{      ~~ expression (args.kwrestarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_blockarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:blockarg, :block)),
+        nil),
+      %q{def f(&block); end},
+      %q{       ~~~~~ name (args.blockarg)
+        |      ~~~~~~ expression (args.blockarg)})
+  end
+
+  def test_arg_scope
+    # [ruby-core:61299] [Bug #9593]
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:optarg, :var, s(:defined?, s(:lvar, :var)))),
+        s(:lvar, :var)),
+      %q{def f(var = defined?(var)) var end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwoptarg, :var, s(:defined?, s(:lvar, :var)))),
+        s(:lvar, :var)),
+      %q{def f(var: defined?(var)) var end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def assert_parses_args(ast, code, versions=ALL_VERSIONS)
+    assert_parses(
+      s(:def, :f, ast, nil),
+      %Q{def f #{code}; end},
+      %q{},
+      versions)
+  end
+
+  def test_arg_combinations
+    # f_arg tCOMMA f_optarg tCOMMA f_rest_arg              opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{a, o=1, *r, &b})
+
+    # f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{a, o=1, *r, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA f_optarg                                opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{a, o=1, &b})
+
+    # f_arg tCOMMA f_optarg tCOMMA                   f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{a, o=1, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA                 f_rest_arg              opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{a, *r, &b})
+
+    # f_arg tCOMMA                 f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{a, *r, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg                                                opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:arg, :a),
+        s(:blockarg, :b)),
+      %q{a, &b})
+
+    #              f_optarg tCOMMA f_rest_arg              opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{o=1, *r, &b})
+
+    #              f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{o=1, *r, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    #              f_optarg                                opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{o=1, &b})
+
+    #              f_optarg tCOMMA                   f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{o=1, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    #                              f_rest_arg              opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{*r, &b})
+
+    #                              f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{*r, p, &b},
+      ALL_VERSIONS - %w(1.8))
+
+    #                                                          f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:blockarg, :b)),
+      %q{&b})
+
+    # (nothing)
+    assert_parses_args(
+      s(:args),
+      %q{})
+  end
+
+  def test_kwarg_combinations
+    # f_kwarg tCOMMA f_kwrest opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:kwoptarg, :bar, s(:int, 2)),
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{(foo: 1, bar: 2, **baz, &b)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwarg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{(foo: 1, &b)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwrest opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{**baz, &b},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_kwarg_no_paren
+    assert_parses_args(
+      s(:args,
+        s(:kwarg, :foo)),
+      %Q{foo:\n},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+
+    assert_parses_args(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, -1))),
+      %Q{foo: -1\n},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def assert_parses_margs(ast, code, versions=ALL_VERSIONS - %w(1.8))
+    assert_parses_args(
+      s(:args, ast),
+      %Q{(#{code})},
+      versions)
+  end
+
+  def test_marg_combinations
+    # tLPAREN f_margs rparen
+    assert_parses_margs(
+      s(:mlhs,
+        s(:mlhs, s(:arg, :a))),
+      %q{((a))})
+
+    # f_marg_list
+    assert_parses_margs(
+      s(:mlhs, s(:arg, :a), s(:arg, :a1)),
+      %q{(a, a1)})
+
+    # f_marg_list tCOMMA tSTAR f_norm_arg
+    assert_parses_margs(
+      s(:mlhs, s(:arg, :a), s(:restarg, :r)),
+      %q{(a, *r)})
+
+    # f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
+    assert_parses_margs(
+      s(:mlhs, s(:arg, :a), s(:restarg, :r), s(:arg, :p)),
+      %q{(a, *r, p)})
+
+    # f_marg_list tCOMMA tSTAR
+    assert_parses_margs(
+      s(:mlhs, s(:arg, :a), s(:restarg)),
+      %q{(a, *)})
+
+    # f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
+    assert_parses_margs(
+      s(:mlhs, s(:arg, :a), s(:restarg), s(:arg, :p)),
+      %q{(a, *, p)})
+
+    # tSTAR f_norm_arg
+    assert_parses_margs(
+      s(:mlhs, s(:restarg, :r)),
+      %q{(*r)})
+
+    # tSTAR f_norm_arg tCOMMA f_marg_list
+    assert_parses_margs(
+      s(:mlhs, s(:restarg, :r), s(:arg, :p)),
+      %q{(*r, p)})
+
+    # tSTAR
+    assert_parses_margs(
+      s(:mlhs, s(:restarg)),
+      %q{(*)})
+
+    # tSTAR tCOMMA f_marg_list
+    assert_parses_margs(
+      s(:mlhs, s(:restarg), s(:arg, :p)),
+      %q{(*, p)})
+  end
+
+  def assert_parses_blockargs(ast, code, versions=ALL_VERSIONS)
+    assert_parses(
+      s(:block,
+        s(:send, nil, :f),
+        ast, nil),
+      %Q{f{ #{code} }},
+      %q{},
+      versions)
+  end
+
+  def test_block_arg_combinations
+    # none
+    assert_parses_blockargs(
+      s(:args),
+      %q{})
+
+    # tPIPE tPIPE
+    # tPIPE opt_bv_decl tPIPE
+    assert_parses_blockargs(
+      s(:args),
+      %q{| |})
+
+    assert_parses_blockargs(
+      s(:args, s(:shadowarg, :a)),
+      %q{|;a|},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:shadowarg, :a)),
+      %Q{|;\na\n|},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # tOROP
+    assert_parses_blockargs(
+      s(:args),
+      %q{||})
+
+    # block_par
+    # block_par tCOMMA
+    # block_par tCOMMA tAMPER lhs
+    # f_arg                                                      opt_f_block_arg
+    # f_arg tCOMMA
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a)),
+      %q{|a|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:arg, :c)),
+      %q{|a, c|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg_expr, s(:ivasgn, :@a))),
+      %q{|@a|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a)),
+      %q{|a,|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:blockarg, :b)),
+      %q{|a, &b|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|a, &@b|},
+      %w(1.8))
+
+    # block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs
+    # block_par tCOMMA tSTAR tCOMMA tAMPER lhs
+    # block_par tCOMMA tSTAR lhs
+    # block_par tCOMMA tSTAR
+    # f_arg tCOMMA                       f_rest_arg              opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:restarg, :s), s(:blockarg, :b)),
+      %q{|a, *s, &b|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a),
+        s(:restarg_expr, s(:ivasgn, :@s)),
+        s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|a, *@s, &@b|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:restarg), s(:blockarg, :b)),
+      %q{|a, *, &b|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a),
+        s(:restarg),
+        s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|a, *, &@b|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:restarg, :s)),
+      %q{|a, *s|})
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a),
+        s(:restarg_expr, s(:ivasgn, :@s))),
+      %q{|a, *@s|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:arg, :a), s(:restarg)),
+      %q{|a, *|})
+
+    # tSTAR lhs tCOMMA tAMPER lhs
+    # tSTAR lhs
+    # tSTAR
+    # tSTAR tCOMMA tAMPER lhs
+    #                                    f_rest_arg              opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args, s(:restarg, :s), s(:blockarg, :b)),
+      %q{|*s, &b|})
+
+    assert_parses_blockargs(
+      s(:args,
+        s(:restarg_expr, s(:ivasgn, :@s)),
+        s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|*@s, &@b|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:restarg), s(:blockarg, :b)),
+      %q{|*, &b|})
+
+    assert_parses_blockargs(
+      s(:args,
+        s(:restarg),
+        s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|*, &@b|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:restarg, :s)),
+      %q{|*s|})
+
+    assert_parses_blockargs(
+      s(:args,
+        s(:restarg_expr, s(:ivasgn, :@s))),
+      %q{|*@s|},
+      %w(1.8))
+
+    assert_parses_blockargs(
+      s(:args, s(:restarg)),
+      %q{|*|})
+
+    # tAMPER lhs
+    #                                                                f_block_arg
+    assert_parses_blockargs(
+      s(:args, s(:blockarg, :b)),
+      %q{|&b|})
+
+    assert_parses_blockargs(
+      s(:args,
+        s(:blockarg_expr, s(:ivasgn, :@b))),
+      %q{|&@b|},
+      %w(1.8))
+
+    # f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg              opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:optarg, :o1, s(:int, 2)),
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{|a, o=1, o1=2, *r, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|a, o=1, *r, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA f_block_optarg                                opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{|a, o=1, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA f_block_optarg tCOMMA                   f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:arg, :a),
+        s(:optarg, :o, s(:int, 1)),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|a, o=1, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    # f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:arg, :a),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|a, *r, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    #              f_block_optarg tCOMMA f_rest_arg              opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:blockarg, :b)),
+      %q{|o=1, *r, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    #              f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|o=1, *r, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    #              f_block_optarg                                opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{|o=1, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    #              f_block_optarg tCOMMA                   f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:optarg, :o, s(:int, 1)),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|o=1, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+
+    #                                    f_rest_arg tCOMMA f_arg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:restarg, :r),
+        s(:arg, :p),
+        s(:blockarg, :b)),
+      %q{|*r, p, &b|},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_block_kwarg_combinations
+    # f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:kwoptarg, :bar, s(:int, 2)),
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{|foo: 1, bar: 2, **baz, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_block_kwarg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{|foo: 1, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwrest opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{|**baz, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_block_kwarg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwarg, :foo)),
+      %q{|foo:|},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_arg_invalid
+    assert_diagnoses(
+      [:error, :argument_const],
+      %q{def foo(Abc); end},
+      %q{        ~~~ location})
+
+    assert_diagnoses(
+      [:error, :argument_ivar],
+      %q{def foo(@abc); end},
+      %q{        ~~~~ location})
+
+    assert_diagnoses(
+      [:error, :argument_gvar],
+      %q{def foo($abc); end},
+      %q{        ~~~~ location})
+
+    assert_diagnoses(
+      [:error, :argument_cvar],
+      %q{def foo(@@abc); end},
+      %q{        ~~~~~ location})
+  end
+
+  def test_arg_duplicate
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, aa); end},
+      %q{            ^^ location
+        |        ~~ highlights (0)})
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, aa=1); end},
+      %q{            ^^ location
+        |        ~~ highlights (0)})
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, *aa); end},
+      %q{             ^^ location
+        |        ~~ highlights (0)})
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, &aa); end},
+      %q{             ^^ location
+        |        ~~ highlights (0)})
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, (bb, aa)); end},
+      %q{                 ^^ location
+        |        ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, *r, aa); end},
+      %q{                ^^ location
+        |        ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8))
+
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{lambda do |aa; aa| end},
+      %q{               ^^ location
+        |           ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, aa: 1); end},
+      %q{            ^^ location
+        |        ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, **aa); end},
+      %q{              ^^ location
+        |        ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(aa, aa:); end},
+      %q{            ^^ location
+        |        ~~ highlights (0)},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_arg_duplicate_ignored
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(_, _); end},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:def, :foo,
+        s(:args, s(:arg, :_), s(:arg, :_)),
+        nil),
+      %q{def foo(_, _); end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{def foo(_a, _a); end},
+      %q{},
+      %w(1.8 1.9))
+
+    assert_parses(
+      s(:def, :foo,
+        s(:args, s(:arg, :_a), s(:arg, :_a)),
+        nil),
+      %q{def foo(_a, _a); end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_arg_duplicate_proc
+    assert_parses(
+      s(:block, s(:send, nil, :proc),
+        s(:args, s(:arg, :a), s(:arg, :a)),
+        nil),
+      %q{proc{|a,a|}},
+      %q{},
+      %w(1.8))
+
+    assert_diagnoses(
+      [:error, :duplicate_argument],
+      %q{proc{|a,a|}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_kwarg_invalid
+    assert_diagnoses(
+      [:error, :argument_const],
+      %q{def foo(Abc: 1); end},
+      %q{        ~~~~ location},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :argument_const],
+      %q{def foo(Abc:); end},
+      %q{        ~~~~ location},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_arg_label
+    assert_parses(
+      s(:def, :foo, s(:args),
+        s(:send, nil, :a, s(:sym, :b))),
+      %q{def foo() a:b end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:def, :foo, s(:args),
+        s(:send, nil, :a, s(:sym, :b))),
+      %Q{def foo\n a:b end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :f),
+        s(:args),
+        s(:send, nil, :a,
+          s(:sym, :b))),
+      %Q{f { || a:b }},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  #
+  # Sends
+  #
+
+  # To self
+
+  def test_send_self
+    assert_parses(
+      s(:send, nil, :fun),
+      %q{fun},
+      %q{~~~ selector
+        |~~~ expression})
+
+    assert_parses(
+      s(:send, nil, :fun!),
+      %q{fun!},
+      %q{~~~~ selector
+        |~~~~ expression})
+
+    assert_parses(
+      s(:send, nil, :fun, s(:int, 1)),
+      %q{fun(1)},
+      %q{~~~ selector
+        |   ^ begin
+        |     ^ end
+        |~~~~~~ expression})
+  end
+
+  def test_send_self_block
+    assert_parses(
+      s(:block, s(:send, nil, :fun), s(:args), nil),
+      %q{fun { }})
+
+    assert_parses(
+      s(:block, s(:send, nil, :fun), s(:args), nil),
+      %q{fun() { }})
+
+    assert_parses(
+      s(:block, s(:send, nil, :fun, s(:int, 1)), s(:args), nil),
+      %q{fun(1) { }})
+
+    assert_parses(
+      s(:block, s(:send, nil, :fun), s(:args), nil),
+      %q{fun do end})
+  end
+
+  def test_send_block_blockarg
+    assert_diagnoses(
+      [:error, :block_and_blockarg],
+      %q{fun(&bar) do end},
+      %q{    ~~~~ location
+        |          ~~ highlights (0)})
+  end
+
+  # To receiver
+
+  def test_send_plain
+    assert_parses(
+      s(:send, s(:lvar, :foo), :fun),
+      %q{foo.fun},
+      %q{    ~~~ selector
+        |   ^ dot
+        |~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :fun),
+      %q{foo::fun},
+      %q{     ~~~ selector
+        |   ^^ dot
+        |~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :Fun),
+      %q{foo::Fun()},
+      %q{     ~~~ selector
+        |   ^^ dot
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_send_plain_cmd
+    assert_parses(
+      s(:send, s(:lvar, :foo), :fun, s(:lvar, :bar)),
+      %q{foo.fun bar},
+      %q{    ~~~ selector
+        |   ^ dot
+        |~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :fun, s(:lvar, :bar)),
+      %q{foo::fun bar},
+      %q{     ~~~ selector
+        |   ^^ dot
+        |~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :Fun, s(:lvar, :bar)),
+      %q{foo::Fun bar},
+      %q{     ~~~ selector
+        |   ^^ dot
+        |~~~~~~~~~~~~ expression})
+  end
+
+  def test_send_plain_cmd_ambiguous_literal
+    assert_diagnoses(
+      [:warning, :ambiguous_literal],
+      %q{m /foo/},
+      %q{  ^ location})
+
+    refute_diagnoses(
+      %q{m %[1]})
+  end
+
+  def test_send_plain_cmd_ambiguous_prefix
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '+' }],
+      %q{m +foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '-' }],
+      %q{m -foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '&' }],
+      %q{m &foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '*' }],
+      %q{m *foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '**' }],
+      %q{m **foo},
+      %q{  ^^ location},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_send_block_chain_cmd
+    assert_parses(
+      s(:send,
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil),
+        :fun, s(:lvar, :bar)),
+      %q{meth 1 do end.fun bar},
+      %q{              ~~~ selector
+        |             ^ dot
+        |~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send,
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil),
+        :fun, s(:lvar, :bar)),
+      %q{meth 1 do end.fun(bar)},
+      %q{              ~~~ selector
+        |             ^ dot
+        |                 ^ begin
+        |                     ^ end
+        |~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send,
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil),
+        :fun, s(:lvar, :bar)),
+      %q{meth 1 do end::fun bar},
+      %q{               ~~~ selector
+        |             ^^ dot
+        |~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send,
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil),
+        :fun, s(:lvar, :bar)),
+      %q{meth 1 do end::fun(bar)},
+      %q{               ~~~ selector
+        |                  ^ begin
+        |                      ^ end
+        |             ^^ dot
+        |~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), nil),
+          :fun, s(:lvar, :bar)),
+        s(:args), nil),
+      %q{meth 1 do end.fun bar do end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), nil),
+          :fun, s(:lvar, :bar)),
+        s(:args), nil),
+      %q{meth 1 do end.fun(bar) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), nil),
+          :fun),
+        s(:args), nil),
+      %q{meth 1 do end.fun {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_send_paren_block_cmd
+    assert_parses(
+      s(:send, nil, :foo,
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil)),
+      %q{foo(meth 1 do end)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :foo,
+        s(:int, 1),
+        s(:block,
+          s(:send, nil, :meth, s(:int, 1)),
+          s(:args), nil)),
+      %q{foo(1, meth 1 do end)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_send_binary_op
+    assert_parses(
+      s(:send, s(:lvar, :foo), :+, s(:int, 1)),
+      %q{foo + 1},
+      %q{    ~ selector
+        |~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :-, s(:int, 1)),
+      %q{foo - 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :*, s(:int, 1)),
+      %q{foo * 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :/, s(:int, 1)),
+      %q{foo / 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :%, s(:int, 1)),
+      %q{foo % 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :**, s(:int, 1)),
+      %q{foo ** 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :|, s(:int, 1)),
+      %q{foo | 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :^, s(:int, 1)),
+      %q{foo ^ 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :&, s(:int, 1)),
+      %q{foo & 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :<=>, s(:int, 1)),
+      %q{foo <=> 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :<, s(:int, 1)),
+      %q{foo < 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :<=, s(:int, 1)),
+      %q{foo <= 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :>, s(:int, 1)),
+      %q{foo > 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :>=, s(:int, 1)),
+      %q{foo >= 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :==, s(:int, 1)),
+      %q{foo == 1})
+
+    assert_parses(
+      s(:not, s(:send, s(:lvar, :foo), :==, s(:int, 1))),
+      %q{foo != 1},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :'!=', s(:int, 1)),
+      %q{foo != 1},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :===, s(:int, 1)),
+      %q{foo === 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :=~, s(:int, 1)),
+      %q{foo =~ 1})
+
+    assert_parses(
+      s(:not, s(:send, s(:lvar, :foo), :=~, s(:int, 1))),
+      %q{foo !~ 1},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :'!~', s(:int, 1)),
+      %q{foo !~ 1},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :<<, s(:int, 1)),
+      %q{foo << 1})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :>>, s(:int, 1)),
+      %q{foo >> 1})
+  end
+
+  def test_send_unary_op
+    assert_parses(
+      s(:send, s(:lvar, :foo), :-@),
+      %q{-foo},
+      %q{~ selector
+        |~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :+@),
+      %q{+foo})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :~),
+      %q{~foo})
+  end
+
+  def test_bang
+    assert_parses(
+      s(:not, s(:lvar, :foo)),
+      %q{!foo},
+      %{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :'!'),
+      %q{!foo},
+      %{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_bang_cmd
+    assert_parses(
+      s(:not, s(:send, nil, :m, s(:lvar, :foo))),
+      %q{!m foo},
+      %{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:send, nil, :m, s(:lvar, :foo)), :'!'),
+      %q{!m foo},
+      %{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_not
+    assert_parses(
+      s(:not, s(:lvar, :foo)),
+      %q{not foo},
+      %{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :'!'),
+      %q{not foo},
+      %{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :'!'),
+      %q{not(foo)},
+      %q{~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, s(:begin), :'!'),
+      %q{not()},
+      %q{~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_not_cmd
+    assert_parses(
+      s(:not, s(:send, nil, :m, s(:lvar, :foo))),
+      %q{not m foo},
+      %{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, s(:send, nil, :m, s(:lvar, :foo)), :'!'),
+      %q{not m foo},
+      %{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_pow_precedence
+    assert_parses(
+      s(:send, s(:send, s(:int, 2), :**, s(:int, 10)), :-@),
+      %q{-2 ** 10})
+
+    assert_parses(
+      s(:send, s(:send, s(:float, 2.0), :**, s(:int, 10)), :-@),
+      %q{-2.0 ** 10})
+  end
+
+  def test_send_attr_asgn
+    assert_parses(
+      s(:send, s(:lvar, :foo), :a=, s(:int, 1)),
+      %q{foo.a = 1},
+      %q{    ~ selector
+        |   ^ dot
+        |      ^ operator
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :a=, s(:int, 1)),
+      %q{foo::a = 1},
+      %q{     ~ selector
+        |   ^^ dot
+        |       ^ operator
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :A=, s(:int, 1)),
+      %q{foo.A = 1},
+      %q{    ~ selector
+        |   ^ dot
+        |      ^ operator
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:casgn, s(:lvar, :foo), :A, s(:int, 1)),
+      %q{foo::A = 1},
+      %q{     ~ name
+        |   ^^ double_colon
+        |       ^ operator
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_send_index
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[],
+        s(:int, 1), s(:int, 2)),
+      %q{foo[1, 2]},
+      %q{   ~~~~~~ selector
+        |~~~~~~~~~ expression})
+  end
+
+  def test_send_index_cmd
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[],
+        s(:send, nil, :m, s(:lvar, :bar))),
+      %q{foo[m bar]})
+  end
+
+  def test_send_index_asgn
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[]=,
+        s(:int, 1), s(:int, 2), s(:int, 3)),
+      %q{foo[1, 2] = 3},
+      %q{   ~~~~~~ selector
+        |          ^ operator
+        |~~~~~~~~~~~~~ expression})
+  end
+
+  def test_send_lambda
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args), nil),
+      %q{->{ }},
+      %q{~~ selector (send)
+        |  ^ begin
+        |    ^ end
+        |~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args, s(:restarg)), nil),
+      %q{-> * { }},
+      %q{~~ selector (send)
+        |     ^ begin
+        |       ^ end
+        |   ^ expression (args.restarg)
+        |~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args), nil),
+      %q{-> do end},
+      %q{~~ selector (send)
+        |   ^^ begin
+        |      ^^^ end
+        |~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_send_lambda_args
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args,
+          s(:arg, :a)),
+        nil),
+      %q{->(a) { }},
+      %q{~~ selector (send)
+        |  ^ begin (args)
+        |    ^ end (args)
+        |      ^ begin
+        |        ^ end
+        |~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args,
+          s(:arg, :a)),
+        nil),
+      %q{-> (a) { }},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_send_lambda_args_shadow
+    assert_parses(
+      s(:block, s(:send, nil, :lambda),
+        s(:args,
+          s(:arg, :a),
+          s(:shadowarg, :foo),
+          s(:shadowarg, :bar)),
+        nil),
+      %q{->(a; foo, bar) { }},
+      %q{      ~~~ expression (args.shadowarg)},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_send_call
+    assert_parses(
+      s(:send, s(:lvar, :foo), :call,
+        s(:int, 1)),
+      %q{foo.(1)},
+      %q{    ^ begin
+        |      ^ end
+        |   ^ dot
+        |~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, s(:lvar, :foo), :call,
+        s(:int, 1)),
+      %q{foo::(1)},
+      %q{     ^ begin
+        |       ^ end
+        |   ^^ dot
+        |~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_lvar_injecting_match
+    assert_parses(
+      s(:begin,
+        s(:match_with_lvasgn,
+          s(:regexp,
+            s(:str, '(?<match>bar)'),
+            s(:regopt)),
+          s(:str, 'bar')),
+        s(:lvar, :match)),
+      %q{/(?<match>bar)/ =~ 'bar'; match},
+      %q{                ~~ selector (match_with_lvasgn)
+        |~~~~~~~~~~~~~~~~~~~~~~~~ expression (match_with_lvasgn)},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_non_lvar_injecting_match
+    assert_parses(
+      s(:send,
+        s(:regexp,
+          s(:begin, s(:str, '(?<match>bar)')),
+          s(:regopt)),
+        :=~,
+        s(:str, 'bar')),
+      %q{/#{'(?<match>bar)'}/ =~ 'bar'})
+  end
+
+  # To superclass
+
+  def test_super
+    assert_parses(
+      s(:super, s(:lvar, :foo)),
+      %q{super(foo)},
+      %q{~~~~~ keyword
+        |     ^ begin
+        |         ^ end
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:super, s(:lvar, :foo)),
+      %q{super foo},
+      %q{~~~~~ keyword
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:super),
+      %q{super()},
+      %q{~~~~~ keyword
+        |     ^ begin
+        |      ^ end
+        |~~~~~~~ expression})
+  end
+
+  def test_zsuper
+    assert_parses(
+      s(:zsuper),
+      %q{super},
+      %q{~~~~~ keyword
+        |~~~~~ expression})
+  end
+
+  def test_super_block
+    assert_parses(
+      s(:block,
+        s(:super, s(:lvar, :foo), s(:lvar, :bar)),
+        s(:args), nil),
+      %q{super foo, bar do end})
+
+    assert_parses(
+      s(:block,
+        s(:zsuper),
+        s(:args), nil),
+      %q{super do end})
+  end
+
+  # To block argument
+
+  def test_yield
+    assert_parses(
+      s(:yield, s(:lvar, :foo)),
+      %q{yield(foo)},
+      %q{~~~~~ keyword
+        |     ^ begin
+        |         ^ end
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:yield, s(:lvar, :foo)),
+      %q{yield foo},
+      %q{~~~~~ keyword
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:yield),
+      %q{yield()},
+      %q{~~~~~ keyword
+        |     ^ begin
+        |      ^ end
+        |~~~~~~~ expression})
+
+    assert_parses(
+      s(:yield),
+      %q{yield},
+      %q{~~~~~ keyword
+        |~~~~~ expression})
+  end
+
+  def test_yield_block
+    assert_diagnoses(
+      [:error, :block_given_to_yield],
+      %q{yield foo do end},
+      %q{~~~~~ location
+        |          ~~ highlights (0)})
+
+    assert_diagnoses(
+      [:error, :block_given_to_yield],
+      %q{yield(&foo)},
+      %q{~~~~~ location
+        |      ~~~~ highlights (0)})
+  end
+
+  # Call arguments
+
+  def test_args_cmd
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:send, nil, :f, s(:lvar, :bar))),
+      %q{fun(f bar)})
+  end
+
+  def test_args_args_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:splat, s(:lvar, :bar))),
+      %q{fun(foo, *bar)})
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(foo, *bar, &baz)})
+  end
+
+  def test_args_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:splat, s(:lvar, :bar))),
+      %q{fun(*bar)})
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(*bar, &baz)})
+  end
+
+  def test_args_block_pass
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:block_pass, s(:lvar, :bar))),
+      %q{fun(&bar)})
+  end
+
+  def test_args_args_comma
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[],
+        s(:lvar, :bar)),
+      %q{foo[bar,]},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_args_assocs
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1)))),
+      %q{fun(:foo => 1)})
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(:foo => 1, &baz)})
+  end
+
+  def test_args_assocs_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun(:foo => 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(:foo => 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_args_assocs_comma
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[],
+        s(:hash, s(:pair, s(:sym, :baz), s(:int, 1)))),
+      %q{foo[:baz => 1,]},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_args_args_assocs
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1)))),
+      %q{fun(foo, :foo => 1)})
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(foo, :foo => 1, &baz)})
+  end
+
+  def test_args_args_assocs_comma
+    assert_parses(
+      s(:send, s(:lvar, :foo), :[],
+        s(:lvar, :bar),
+        s(:hash, s(:pair, s(:sym, :baz), s(:int, 1)))),
+      %q{foo[bar, :baz => 1,]},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_args_args_assocs_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun(foo, :foo => 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun(foo, :foo => 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  # Call arguments with whitespace
+
+  def test_space_args_cmd
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:begin, s(:send, nil, :f, s(:lvar, :bar)))),
+      %q{fun (f bar)})
+  end
+
+  def test_space_args_arg
+    assert_parses(
+      s(:send, nil, :fun, s(:begin, s(:int, 1))),
+      %q{fun (1)})
+  end
+
+  def test_space_args_arg_block
+    assert_parses(
+      s(:block,
+        s(:send, nil, :fun, s(:begin, s(:int, 1))),
+        s(:args), nil),
+      %q{fun (1) {}})
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:args), nil),
+      %q{foo.fun (1) {}},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
+        s(:args), nil),
+      %q{foo.fun (1) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:int, 1)),
+        s(:args), nil),
+      %q{foo::fun (1) {}},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
+        s(:args), nil),
+      %q{foo::fun (1) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_space_args_arg_call
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:send, s(:begin, s(:int, 1)), :to_i)),
+      %q{fun (1).to_i})
+  end
+
+  def test_space_args_block_pass
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:block_pass, s(:lvar, :foo))),
+      %q{fun (&foo)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_arg_block_pass
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:block_pass, s(:lvar, :bar))),
+      %q{fun (foo, &bar)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_args_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:splat, s(:lvar, :bar))),
+      %q{fun (foo, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, *bar, &baz)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun (foo, 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:splat, s(:lvar, :bar))),
+      %q{fun (*bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (*bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_assocs
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1)))),
+      %q{fun (:foo => 1)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (:foo => 1, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_assocs_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun (:foo => 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (:foo => 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_args_assocs
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1)))),
+      %q{fun (foo, :foo => 1)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, :foo => 1, &baz)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1)))),
+      %q{fun (foo, 1, :foo => 1)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, 1, :foo => 1, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_args_assocs_star
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun (foo, :foo => 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, :foo => 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar))),
+      %q{fun (foo, 1, :foo => 1, *bar)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :fun,
+        s(:lvar, :foo), s(:int, 1),
+        s(:hash, s(:pair, s(:sym, :foo), s(:int, 1))),
+        s(:splat, s(:lvar, :bar)),
+        s(:block_pass, s(:lvar, :baz))),
+      %q{fun (foo, 1, :foo => 1, *bar, &baz)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_arg_arg
+    assert_parses(
+      s(:send, nil, :fun, s(:int, 1), s(:int, 2)),
+      %q{fun (1, 2)},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_none
+    assert_parses(
+      s(:send, nil, :fun),
+      %q{fun ()},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_space_args_block
+    assert_parses(
+      s(:block,
+        s(:send, nil, :fun),
+        s(:args), nil),
+      %q{fun () {}},
+      %q{    ^ begin (send)
+        |     ^ end (send)},
+      %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun),
+        s(:args), nil),
+      %q{foo.fun () {}},
+      %q{        ^ begin (send)
+        |         ^ end (send)},
+      %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, s(:lvar, :foo), :fun),
+        s(:args), nil),
+      %q{foo::fun () {}},
+      %q{         ^ begin (send)
+        |          ^ end (send)},
+      %w(1.8))
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :fun,
+          s(:begin)),
+        s(:args), nil),
+      %q{fun () {}},
+      %q{    ~~ expression (send.begin)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  #
+  # Control flow
+  #
+
+  # Operators
+
+  def test_and
+    assert_parses(
+      s(:and, s(:lvar, :foo), s(:lvar, :bar)),
+      %q{foo and bar},
+      %q{    ~~~ operator
+        |~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:and, s(:lvar, :foo), s(:lvar, :bar)),
+      %q{foo && bar},
+      %q{    ~~ operator
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_or
+    assert_parses(
+      s(:or, s(:lvar, :foo), s(:lvar, :bar)),
+      %q{foo or bar},
+      %q{    ~~ operator
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:or, s(:lvar, :foo), s(:lvar, :bar)),
+      %q{foo || bar},
+      %q{    ~~ operator
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_and_or_masgn
+    assert_parses(
+      s(:and,
+        s(:lvar, :foo),
+        s(:begin,
+          s(:masgn,
+            s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+            s(:lvar, :bar)))),
+      %q{foo && (a, b = bar)})
+
+    assert_parses(
+      s(:or,
+        s(:lvar, :foo),
+        s(:begin,
+          s(:masgn,
+            s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+            s(:lvar, :bar)))),
+      %q{foo || (a, b = bar)})
+  end
+
+  # Branching
+
+  def test_if
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), nil),
+      %q{if foo then bar; end},
+      %q{~~ keyword
+        |       ~~~~ begin
+        |                 ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), nil),
+      %q{if foo; bar; end},
+      %q{~~ keyword
+        |             ~~~ end
+        |~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_if_nl_then
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), nil),
+      %Q{if foo\nthen bar end},
+       %q{       ~~~~ begin})
+  end
+
+  def test_if_mod
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), nil),
+      %q{bar if foo},
+      %q{    ~~ keyword
+        |~~~~~~~~~~ expression})
+  end
+
+  def test_unless
+    assert_parses(
+      s(:if, s(:lvar, :foo), nil, s(:lvar, :bar)),
+      %q{unless foo then bar; end},
+      %q{~~~~~~ keyword
+        |           ~~~~ begin
+        |                     ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:if, s(:lvar, :foo), nil, s(:lvar, :bar)),
+      %q{unless foo; bar; end},
+      %q{~~~~~~ keyword
+        |                 ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_unless_mod
+    assert_parses(
+      s(:if, s(:lvar, :foo), nil, s(:lvar, :bar)),
+      %q{bar unless foo},
+      %q{    ~~~~~~ keyword
+        |~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_if_else
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), s(:lvar, :baz)),
+      %q{if foo then bar; else baz; end},
+      %q{~~ keyword
+        |       ~~~~ begin
+        |                 ~~~~ else
+        |                           ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar), s(:lvar, :baz)),
+      %q{if foo; bar; else baz; end},
+      %q{~~ keyword
+        |             ~~~~ else
+        |                       ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_unless_else
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :baz), s(:lvar, :bar)),
+      %q{unless foo then bar; else baz; end},
+      %q{~~~~~~ keyword
+        |           ~~~~ begin
+        |                     ~~~~ else
+        |                               ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :baz), s(:lvar, :bar)),
+      %q{unless foo; bar; else baz; end},
+      %q{~~~~~~ keyword
+        |                 ~~~~ else
+        |                           ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_if_elsif
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:lvar, :bar),
+        s(:if, s(:lvar, :baz), s(:int, 1), s(:int, 2))),
+      %q{if foo; bar; elsif baz; 1; else 2; end},
+      %q{~~ keyword
+        |             ~~~~~ else
+        |             ~~~~~ keyword (if)
+        |                           ~~~~ else (if)
+        |                                   ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_ternary
+    assert_parses(
+      s(:if, s(:lvar, :foo), s(:int, 1), s(:int, 2)),
+      %q{foo ? 1 : 2},
+      %q{    ^ question
+        |        ^ colon
+        |~~~~~~~~~~~ expression})
+  end
+
+  def test_ternary_ambiguous_symbol
+    assert_parses(
+      s(:begin,
+        s(:lvasgn, :t, s(:int, 1)),
+        s(:if, s(:begin, s(:lvar, :foo)),
+          s(:lvar, :t),
+          s(:const, nil, :T))),
+      %q{t=1;(foo)?t:T},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_if_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{if (a, b = foo); end},
+      %q{    ~~~~~~~~~~ location})
+  end
+
+  def test_if_mod_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{1 if (a, b = foo)},
+      %q{      ~~~~~~~~~~ location})
+  end
+
+  def test_tern_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{(a, b = foo) ? 1 : 2},
+      %q{ ~~~~~~~~~~ location})
+  end
+
+  def test_cond_begin
+    assert_parses(
+      s(:if,
+        s(:begin, s(:lvar, :bar)),
+        s(:lvar, :foo),
+        nil),
+      %q{if (bar); foo; end})
+  end
+
+  def test_cond_begin_masgn
+    assert_parses(
+      s(:if,
+        s(:begin,
+          s(:lvar, :bar),
+          s(:masgn,
+            s(:mlhs, s(:lvasgn, :a), s(:lvasgn, :b)),
+            s(:lvar, :foo))),
+        nil, nil),
+      %q{if (bar; a, b = foo); end})
+  end
+
+  def test_cond_begin_and_or_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{if foo && (a, b = bar); end},
+      %q{           ~~~~~~~~~~ location},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{if foo || (a, b = bar); end},
+      %q{           ~~~~~~~~~~ location},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:if,
+        s(:and,
+          s(:begin,
+            s(:masgn,
+              s(:mlhs,
+                s(:lvasgn, :a), s(:lvasgn, :b)),
+              s(:lvar, :foo))),
+          s(:lvar, :bar)),
+        nil, nil),
+      %q{if (a, b = foo) && bar; end},
+      %q{},
+      %w(1.8))
+  end
+
+  def test_cond_iflipflop
+    assert_parses(
+      s(:if, s(:iflipflop, s(:lvar, :foo), s(:lvar, :bar)),
+        nil, nil),
+      %q{if foo..bar; end},
+      %q{   ~~~~~~~~ expression (iflipflop)
+        |      ~~ operator (iflipflop)})
+  end
+
+  def test_cond_eflipflop
+    assert_parses(
+      s(:if, s(:eflipflop, s(:lvar, :foo), s(:lvar, :bar)),
+        nil, nil),
+      %q{if foo...bar; end},
+      %q{   ~~~~~~~~~ expression (eflipflop)
+        |      ~~~ operator (eflipflop)})
+  end
+
+  def test_cond_match_current_line
+    assert_parses(
+      s(:if,
+        s(:match_current_line,
+          s(:regexp,
+            s(:str, 'wat'),
+            s(:regopt))),
+        nil, nil),
+      %q{if /wat/; end},
+      %q{   ~~~~~ expression (match_current_line)})
+  end
+
+  # Case matching
+
+  def test_case_expr
+    assert_parses(
+      s(:case, s(:lvar, :foo),
+        s(:when, s(:str, 'bar'),
+          s(:lvar, :bar)),
+        nil),
+      %q{case foo; when 'bar'; bar; end},
+      %q{~~~~ keyword
+        |          ~~~~ keyword (when)
+        |                           ~~~ end
+        |          ~~~~~~~~~~~~~~~ expression (when)
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_case_expr_else
+    assert_parses(
+      s(:case, s(:lvar, :foo),
+        s(:when, s(:str, 'bar'),
+          s(:lvar, :bar)),
+        s(:lvar, :baz)),
+      %q{case foo; when 'bar'; bar; else baz; end},
+      %q{~~~~ keyword
+        |          ~~~~ keyword (when)
+        |                           ~~~~ else
+        |                                     ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_case_cond
+    assert_parses(
+      s(:case, nil,
+        s(:when, s(:lvar, :foo),
+          s(:str, 'foo')),
+        nil),
+      %q{case; when foo; 'foo'; end},
+      %q{~~~~ keyword
+        |      ~~~~ keyword (when)
+        |                       ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_case_cond_else
+    assert_parses(
+      s(:case, nil,
+        s(:when, s(:lvar, :foo),
+          s(:str, 'foo')),
+        s(:str, 'bar')),
+      %q{case; when foo; 'foo'; else 'bar'; end},
+      %q{~~~~ keyword
+        |      ~~~~ keyword (when)
+        |                       ~~~~ else
+        |                                   ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_case_cond_just_else
+    assert_parses(
+      s(:case, nil,
+        s(:str, 'bar')),
+      %q{case; else 'bar'; end},
+      %q{~~~~ keyword
+        |      ~~~~ else
+        |                  ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~ expression},
+      %w(1.8))
+  end
+
+  def test_when_then
+    assert_parses(
+      s(:case, s(:lvar, :foo),
+        s(:when, s(:str, 'bar'),
+          s(:lvar, :bar)),
+        nil),
+      %q{case foo; when 'bar' then bar; end},
+      %q{          ~~~~ keyword (when)
+        |                     ~~~~ begin (when)
+        |          ~~~~~~~~~~~~~~~~~~~ expression (when)})
+  end
+
+  def test_when_multi
+    assert_parses(
+      s(:case, s(:lvar, :foo),
+        s(:when, s(:str, 'bar'), s(:str, 'baz'),
+          s(:lvar, :bar)),
+        nil),
+      %q{case foo; when 'bar', 'baz'; bar; end})
+  end
+
+  def test_when_splat
+    assert_parses(
+      s(:case, s(:lvar, :foo),
+        s(:when,
+          s(:int, 1),
+          s(:splat, s(:lvar, :baz)),
+          s(:lvar, :bar)),
+        s(:when,
+          s(:splat, s(:lvar, :foo)),
+          nil),
+        nil),
+      %q{case foo; when 1, *baz; bar; when *foo; end},
+      %q{                  ^ operator (when/1.splat)
+        |                  ~~~~ expression (when/1.splat)
+        |                                  ^ operator (when/2.splat)
+        |                                  ~~~~ expression (when/2.splat)})
+  end
+
+  # Looping
+
+  def test_while
+    assert_parses(
+      s(:while, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{while foo do meth end},
+      %q{~~~~~ keyword
+        |          ~~ begin
+        |                  ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:while, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{while foo; meth end},
+      %q{~~~~~ keyword
+        |                ~~~ end
+        |~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_while_mod
+    assert_parses(
+      s(:while, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{meth while foo},
+      %q{     ~~~~~ keyword})
+  end
+
+  def test_until
+    assert_parses(
+      s(:until, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{until foo do meth end},
+      %q{~~~~~ keyword
+        |          ~~ begin
+        |                  ~~~ end})
+
+    assert_parses(
+      s(:until, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{until foo; meth end},
+      %q{~~~~~ keyword
+        |                ~~~ end})
+  end
+
+  def test_until_mod
+    assert_parses(
+      s(:until, s(:lvar, :foo), s(:send, nil, :meth)),
+      %q{meth until foo},
+      %q{     ~~~~~ keyword})
+  end
+
+  def test_while_post
+    assert_parses(
+      s(:while_post, s(:lvar, :foo),
+        s(:kwbegin, s(:send, nil, :meth))),
+      %q{begin meth end while foo},
+      %q{               ~~~~~ keyword})
+  end
+
+  def test_until_post
+    assert_parses(
+      s(:until_post, s(:lvar, :foo),
+        s(:kwbegin, s(:send, nil, :meth))),
+      %q{begin meth end until foo},
+      %q{               ~~~~~ keyword})
+  end
+
+  def test_while_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{while (a, b = foo); end},
+      %q{       ~~~~~~~~~~ location})
+  end
+
+  def test_while_mod_masgn
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{foo while (a, b = foo)},
+      %q{           ~~~~~~~~~~ location})
+  end
+
+  def test_for
+    assert_parses(
+      s(:for,
+        s(:lvasgn, :a),
+        s(:lvar, :foo),
+        s(:send, nil, :p, s(:lvar, :a))),
+      %q{for a in foo do p a; end},
+      %q{~~~ keyword
+        |      ~~ in
+        |             ~~ begin
+        |                     ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:for,
+        s(:lvasgn, :a),
+        s(:lvar, :foo),
+        s(:send, nil, :p, s(:lvar, :a))),
+      %q{for a in foo; p a; end})
+  end
+
+  def test_for_mlhs
+    assert_parses(
+      s(:for,
+        s(:mlhs,
+          s(:lvasgn, :a),
+          s(:lvasgn, :b)),
+        s(:lvar, :foo),
+        s(:send, nil, :p, s(:lvar, :a), s(:lvar, :b))),
+      %q{for a, b in foo; p a, b; end},
+      %q{    ~~~~ expression (mlhs)})
+  end
+
+  # Control flow commands
+
+  def test_break
+    assert_parses(
+      s(:break, s(:begin, s(:lvar, :foo))),
+      %q{break(foo)},
+      %q{~~~~~ keyword
+        |~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:break, s(:begin, s(:lvar, :foo))),
+      %q{break(foo)},
+      %q{~~~~~ keyword
+        |~~~~~~~~~~ expression},
+      %w(1.8))
+
+    assert_parses(
+      s(:break, s(:lvar, :foo)),
+      %q{break foo},
+      %q{~~~~~ keyword
+        |~~~~~~~~~ expression})
+
+    assert_parses(
+        s(:break, s(:begin)),
+      %q{break()},
+      %q{~~~~~ keyword
+        |~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:break),
+      %q{break},
+      %q{~~~~~ keyword
+        |~~~~~ expression})
+  end
+
+  def test_break_block
+    assert_parses(
+      s(:break,
+        s(:block,
+          s(:send, nil, :fun, s(:lvar, :foo)),
+          s(:args), nil)),
+      %q{break fun foo do end},
+      %q{      ~~~~~~~~~~~~~~ expression (block)
+        |~~~~~~~~~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_return
+    assert_parses(
+      s(:return, s(:begin, s(:lvar, :foo))),
+      %q{return(foo)},
+      %q{~~~~~~ keyword
+        |~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:return, s(:begin, s(:lvar, :foo))),
+      %q{return(foo)},
+      %q{~~~~~~ keyword
+        |~~~~~~~~~~~ expression},
+      %w(1.8))
+
+    assert_parses(
+      s(:return, s(:lvar, :foo)),
+      %q{return foo},
+      %q{~~~~~~ keyword
+        |~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:return, s(:begin)),
+      %q{return()},
+      %q{~~~~~~ keyword
+        |~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:return),
+      %q{return},
+      %q{~~~~~~ keyword
+        |~~~~~~ expression})
+  end
+
+  def test_return_block
+    assert_parses(
+      s(:return,
+        s(:block,
+          s(:send, nil, :fun, s(:lvar, :foo)),
+          s(:args), nil)),
+      %q{return fun foo do end},
+      %q{       ~~~~~~~~~~~~~~ expression (block)
+        |~~~~~~~~~~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_next
+    assert_parses(
+      s(:next, s(:begin, s(:lvar, :foo))),
+      %q{next(foo)},
+      %q{~~~~ keyword
+        |~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:next, s(:begin, s(:lvar, :foo))),
+      %q{next(foo)},
+      %q{~~~~ keyword
+        |~~~~~~~~~ expression},
+      %w(1.8))
+
+    assert_parses(
+      s(:next, s(:lvar, :foo)),
+      %q{next foo},
+      %q{~~~~ keyword
+        |~~~~~~~~ expression})
+
+    assert_parses(
+        s(:next, s(:begin)),
+      %q{next()},
+      %q{~~~~ keyword
+        |~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:next),
+      %q{next},
+      %q{~~~~ keyword
+        |~~~~ expression})
+  end
+
+  def test_next_block
+    assert_parses(
+      s(:next,
+        s(:block,
+          s(:send, nil, :fun, s(:lvar, :foo)),
+          s(:args), nil)),
+      %q{next fun foo do end},
+      %q{     ~~~~~~~~~~~~~~ expression (block)
+        |~~~~~~~~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_redo
+    assert_parses(
+      s(:redo),
+      %q{redo},
+      %q{~~~~ keyword
+        |~~~~ expression})
+  end
+
+  # Exception handling
+
+  def test_rescue
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue, s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :foo)),
+          nil)),
+      %q{begin; meth; rescue; foo; end},
+      %q{~~~~~ begin
+        |             ~~~~~~ keyword (rescue.resbody)
+        |             ~~~~~~~~~~~ expression (rescue.resbody)
+        |       ~~~~~~~~~~~~~~~~~ expression (rescue)
+        |                          ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_rescue_else
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue, s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :foo)),
+          s(:lvar, :bar))),
+      %q{begin; meth; rescue; foo; else; bar; end},
+      %q{                          ~~~~ else (rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
+  end
+
+  def test_rescue_else_useless
+    assert_diagnoses(
+      [:warning, :useless_else],
+      %q{begin; 1; else; 2; end},
+      %q{          ~~~~ location})
+  end
+
+  def test_ensure
+    assert_parses(
+      s(:kwbegin,
+        s(:ensure, s(:send, nil, :meth),
+          s(:lvar, :bar))),
+      %q{begin; meth; ensure; bar; end},
+      %q{~~~~~ begin
+        |             ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~ expression (ensure)
+        |                          ~~~ end
+        |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_ensure_empty
+    assert_parses(
+      s(:kwbegin,
+        s(:ensure, nil, nil)),
+      %q{begin ensure end},
+      %q{~~~~~ begin
+        |      ~~~~~~ keyword (ensure)
+        |      ~~~~~~ expression (ensure)
+        |             ~~~ end
+        |~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_rescue_ensure
+    assert_parses(
+      s(:kwbegin,
+        s(:ensure,
+          s(:rescue,
+            s(:send, nil, :meth),
+            s(:resbody, nil, nil, s(:lvar, :baz)),
+            nil),
+          s(:lvar, :bar))),
+      %q{begin; meth; rescue; baz; ensure; bar; end},
+      %q{                          ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure)
+        |             ~~~~~~ keyword (ensure.rescue.resbody)
+        |       ~~~~~~~~~~~~~~~~~ expression (ensure.rescue)})
+  end
+
+  def test_rescue_else_ensure
+    assert_parses(
+      s(:kwbegin,
+        s(:ensure,
+          s(:rescue,
+            s(:send, nil, :meth),
+            s(:resbody, nil, nil, s(:lvar, :baz)),
+            s(:lvar, :foo)),
+          s(:lvar, :bar))),
+      %q{begin; meth; rescue; baz; else foo; ensure; bar end},
+      %q{                                    ~~~~~~ keyword (ensure)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure)
+        |             ~~~~~~ keyword (ensure.rescue.resbody)
+        |                          ~~~~ else (ensure.rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure.rescue)})
+  end
+
+  def test_rescue_mod
+    assert_parses(
+      s(:rescue,
+        s(:send, nil, :meth),
+        s(:resbody, nil, nil, s(:lvar, :bar)),
+        nil),
+      %q{meth rescue bar},
+      %q{     ~~~~~~ keyword (resbody)
+        |     ~~~~~~~~~~ expression (resbody)
+        |~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_rescue_mod_asgn
+    assert_parses(
+      s(:lvasgn, :foo,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :bar)),
+          nil)),
+      %q{foo = meth rescue bar},
+      %q{           ~~~~~~ keyword (rescue.resbody)
+        |           ~~~~~~~~~~ expression (rescue.resbody)
+        |      ~~~~~~~~~~~~~~~ expression (rescue)
+        |~~~~~~~~~~~~~~~~~~~~~ expression})
+  end
+
+  def test_rescue_mod_op_assign
+    assert_parses(
+      s(:op_asgn,
+        s(:lvasgn, :foo), :+,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, nil, s(:lvar, :bar)),
+          nil)),
+      %q{foo += meth rescue bar},
+      %q{            ~~~~~~ keyword (rescue.resbody)
+        |            ~~~~~~~~~~ expression (rescue.resbody)
+        |       ~~~~~~~~~~~~~~~ expression (rescue)
+        |~~~~~~~~~~~~~~~~~~~~~~ expression},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_resbody_list
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array, s(:const, nil, :Exception)),
+            nil,
+            s(:lvar, :bar)),
+          nil)),
+      %q{begin; meth; rescue Exception; bar; end})
+  end
+
+  def test_resbody_list_mrhs
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array,
+              s(:const, nil, :Exception),
+              s(:lvar, :foo)),
+            nil,
+            s(:lvar, :bar)),
+          nil)),
+      %q{begin; meth; rescue Exception, foo; bar; end})
+  end
+
+  def test_resbody_var
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, s(:lvasgn, :ex), s(:lvar, :bar)),
+          nil)),
+      %q{begin; meth; rescue => ex; bar; end})
+
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody, nil, s(:ivasgn, :@ex), s(:lvar, :bar)),
+          nil)),
+      %q{begin; meth; rescue => @ex; bar; end})
+  end
+
+  def test_resbody_list_var
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue,
+          s(:send, nil, :meth),
+          s(:resbody,
+            s(:array, s(:lvar, :foo)),
+            s(:lvasgn, :ex),
+            s(:lvar, :bar)),
+          nil)),
+      %q{begin; meth; rescue foo => ex; bar; end})
+  end
+
+  def test_retry
+    assert_parses(
+      s(:retry),
+      %q{retry},
+      %q{~~~~~ keyword
+        |~~~~~ expression})
+  end
+
+  # BEGIN and END
+
+  def test_preexe
+    assert_parses(
+      s(:preexe, s(:int, 1)),
+      %q{BEGIN { 1 }},
+      %q{~~~~~ keyword
+        |      ^ begin
+        |          ^ end
+        |~~~~~~~~~~~ expression})
+  end
+
+  def test_preexe_invalid
+    assert_diagnoses(
+      [:error, :begin_in_method],
+      %q{def f; BEGIN{}; end},
+      %q{       ~~~~~ location},
+      # Yes. *Exclude 1.9*. Sigh.
+      ALL_VERSIONS - %w(1.9))
+  end
+
+  def test_postexe
+    assert_parses(
+      s(:postexe, s(:int, 1)),
+      %q{END { 1 }},
+      %q{~~~ keyword
+        |    ^ begin
+        |        ^ end
+        |~~~~~~~~~ expression})
+  end
+
+  #
+  # Miscellanea
+  #
+
+  def test_kwbegin_compstmt
+    assert_parses(
+      s(:kwbegin,
+        s(:send, nil, :foo!),
+        s(:send, nil, :bar!)),
+      %q{begin foo!; bar! end})
+  end
+
+  def test_crlf_line_endings
+    with_versions(ALL_VERSIONS) do |_ver, parser|
+      source_file = Parser::Source::Buffer.new('(comments)')
+      source_file.source = "\r\nfoo"
+
+      range = lambda do |from, to|
+        Parser::Source::Range.new(source_file, from, to)
+      end
+
+      ast = parser.parse(source_file)
+
+      assert_equal s(:lvar, :foo),
+                   ast
+
+      assert_equal range.call(1, 4),
+                   ast.loc.expression
+    end
+  end
+
+  def test_begin_cmdarg
+    assert_parses(
+      s(:send, nil, :p,
+        s(:kwbegin,
+          s(:block,
+            s(:send, s(:int, 1), :times),
+            s(:args),
+            s(:int, 1)))),
+      %q{p begin 1.times do 1 end end},
+      %{},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_bug_cmdarg
+    assert_parses(
+      s(:send, nil, :meth,
+        s(:begin,
+          s(:block,
+            s(:send, nil, :lambda),
+            s(:args), nil))),
+      %q{meth (lambda do end)},
+      %q{},
+      %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :assert,
+        s(:send, nil, :dogs)),
+      %q{assert dogs})
+
+    assert_parses(
+      s(:send, nil, :assert,
+        s(:hash,
+          s(:pair, s(:sym, :do), s(:true)))),
+      %q{assert do: true},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+
+    assert_parses(
+      s(:send, nil, :f,
+        s(:hash,
+          s(:pair,
+            s(:sym, :x),
+            s(:block,
+              s(:send, nil, :lambda),
+              s(:args),
+              s(:block,
+                s(:send, nil, :meth),
+                s(:args), nil))))),
+      %q{f x: -> do meth do end end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_file_line_non_literals
+    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__]"
+
+      ast = parser.parse(source_file)
+
+      assert_equal s(:array, s(:__FILE__), s(:__LINE__)), ast
+    end
+  end
+
+  if defined?(Encoding)
+    def test_bom
+      assert_parses(
+        s(:int, 1),
+        %Q{\xef\xbb\xbf1}.force_encoding(Encoding::BINARY),
+        %q{},
+        %w(1.9 2.0 2.1))
+    end
+
+    def test_magic_encoding_comment
+      assert_parses(
+        s(:begin,
+          s(:lvasgn, :"проверка", s(:int, 42)),
+          s(:send, nil, :puts, s(:lvar, :"проверка"))),
+        %Q{# coding:koi8-r
+           \xd0\xd2\xcf\xd7\xc5\xd2\xcb\xc1 = 42
+           puts \xd0\xd2\xcf\xd7\xc5\xd2\xcb\xc1}.
+          force_encoding(Encoding::BINARY),
+        %q{},
+        %w(1.9 2.0 2.1))
+    end
+
+    def test_regexp_encoding
+      assert_parses(
+        s(:match_with_lvasgn,
+          s(:regexp,
+            s(:str, "\\xa8"),
+            s(:regopt, :n)),
+          s(:str, "")),
+        %q{/\xa8/n =~ ""}.force_encoding(Encoding::UTF_8),
+        %{},
+        ALL_VERSIONS - %w(1.8))
+    end
+  end
+
+  #
+  # Error recovery
+  #
+
+  def test_unknown_percent_str
+    assert_diagnoses(
+      [:error, :unexpected_percent_str, { :type => '%k' }],
+      %q{%k[foo]},
+      %q{~~ location})
+  end
+
+  def test_unterminated_embedded_doc
+    assert_diagnoses(
+      [:fatal, :embedded_document],
+      %Q{=begin\nfoo\nend},
+      %q{~~~~~~ location})
+
+    assert_diagnoses(
+      [:fatal, :embedded_document],
+      %Q{=begin\nfoo\nend\n},
+      %q{~~~~~~ location})
+  end
+
+  def test_codepoint_too_large
+    assert_diagnoses(
+      [:error, :unicode_point_too_large],
+      %q{"\u{120 120000}"},
+      %q{        ~~~~~~ location},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_on_error
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tIDENTIFIER' }],
+      %q{def foo(bar baz); end},
+      %q{            ~~~ location})
+  end
+
+  #
+  # Token and comment extraction
+  #
+
+  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
+
+      comments_pattern_here = comments_pattern.map do |(from, to)|
+        range = Parser::Source::Range.new(source_file, from, to)
+        Parser::Source::Comment.new(range)
+      end
+
+      ast, comments = parser.parse_with_comments(source_file)
+
+      assert_equal ast_pattern, ast
+
+      assert_equal comments_pattern_here, comments
+    end
+  end
+
+  def test_comment_interleaved
+    assert_parses_with_comments(
+      s(:send, s(:int, 1), :+, s(:int, 2)),
+      %Q{1 + # foo\n 2},
+      [ [4, 9] ])
+  end
+
+  def test_comment_single
+    assert_parses_with_comments(
+      s(:send, nil, :puts),
+      %Q{puts # whatever},
+      [ [5, 15] ])
+  end
+
+  def test_tokenize
+    with_versions(ALL_VERSIONS) do |_ver, parser|
+      source_file = Parser::Source::Buffer.new('(tokenize)')
+      source_file.source = "1 + # foo\n 2"
+
+      range = lambda do |from, to|
+        Parser::Source::Range.new(source_file, from, to)
+      end
+
+      ast, comments, tokens = parser.tokenize(source_file)
+
+      assert_equal s(:send, s(:int, 1), :+, s(:int, 2)),
+                   ast
+
+      assert_equal [
+                     Parser::Source::Comment.new(range.call(4, 9))
+                   ], comments
+
+      assert_equal [
+                     [:tINTEGER, [ 1,       range.call(0, 1) ]],
+                     [:tPLUS,    [ '+',     range.call(2, 3) ]],
+                     [:tCOMMENT, [ '# foo', range.call(4, 9) ]],
+                     [:tINTEGER, [ 2,       range.call(11, 12) ]],
+                   ], tokens
+    end
+  end
+
+  #
+  # Bug-specific tests
+  #
+
+  def test_bug_cmd_string_lookahead
+    assert_parses(
+      s(:block,
+        s(:send, nil, :desc,
+          s(:str, 'foo')),
+        s(:args), nil),
+      %q{desc "foo" do end})
+  end
+
+  def test_bug_do_block_in_call_args
+    # [ruby-core:59342] [Bug #9308]
+    assert_parses(
+      s(:send, nil, :bar,
+        s(:def, :foo,
+          s(:args),
+          s(:block,
+            s(:send, s(:self), :each),
+            s(:args),
+            nil))),
+      %q{bar def foo; self.each do end end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_bug_do_block_in_cmdarg
+    # [ruby-core:61950] [Bug #9726]
+    assert_parses(
+      s(:send, nil, :tap,
+        s(:begin,
+          s(:block,
+            s(:send, nil, :proc),
+            s(:args), nil))),
+      %q{tap (proc do end)},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_bug_interp_single
+    assert_parses(
+      s(:dstr, s(:begin, s(:int, 1))),
+      %q{"#{1}"})
+
+    assert_parses(
+      s(:array, s(:dstr, s(:begin, s(:int, 1)))),
+      %q{%W"#{1}"})
+  end
+
+  def test_bug_def_no_paren_eql_begin
+    assert_parses(
+      s(:def, :foo, s(:args), nil),
+      %Q{def foo\n=begin\n=end\nend})
+  end
+
+  def test_bug_while_not_parens_do
+    assert_parses(
+      s(:while, s(:send, s(:begin, s(:true)), :"!"), nil),
+      %q{while not (true) do end},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+
+  def test_bug_rescue_empty_else
+    assert_parses(
+      s(:kwbegin,
+        s(:rescue, nil,
+          s(:resbody,
+            s(:array,
+              s(:const, nil, :LoadError)), nil, nil), nil)),
+      %q{begin; rescue LoadError; else; end},
+      %q{                         ~~~~ else (rescue)
+        |       ~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)})
+  end
+
+  def test_bug_heredoc_do
+    assert_parses(
+      s(:block,
+        s(:send, nil, :f,
+          s(:dstr)),
+        s(:args), nil),
+      %Q{f <<-TABLE do\nTABLE\nend})
+  end
+
+  def test_bug_lambda_leakage
+    assert_parses(
+      s(:begin,
+        s(:block,
+          s(:send, nil, :lambda),
+          s(:args,
+            s(:arg, :scope)), nil),
+        s(:send, nil, :scope)),
+      %q{->(scope) {}; scope},
+      %q{},
+      ALL_VERSIONS - %w(1.8))
+  end
+end