parser 2.0.0.beta5 → 2.0.0.beta6

data/lib/parser/lexer.rl

@@ -677,7 +677,7 @@ class Parser::Lexer
     # After every heredoc was parsed, @herebody_s contains the
     # position of next token after all heredocs.
     if @herebody_s
-      p = @herebody_s - 1
+      p = @herebody_s
       @herebody_s = nil
     end
   };
@@ -819,9 +819,9 @@ class Parser::Lexer
     if literal
       if literal.end_interp_brace_and_try_closing
         if version?(18, 19)
-          emit(:tRCURLY, '}')
+          emit(:tRCURLY, '}', p - 1, p)
         else
-          emit(:tSTRING_DEND, '}')
+          emit(:tSTRING_DEND, '}', p - 1, p)
         end
 
         if literal.saved_herebody_s
@@ -1056,7 +1056,7 @@ class Parser::Lexer
 
       global_var
       => { p = @ts - 1
-           fcall expr_variable; };
+           fnext expr_end; fcall expr_variable; };
 
       # If the handling was to be delegated to expr_end,
       # these cases would transition to something else than

data/lib/parser/ruby18.y

@@ -227,11 +227,11 @@ rule
                     }
                 | kNOT expr
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | tBANG command_call
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | arg
 
@@ -714,7 +714,7 @@ rule
                     }
                 | tBANG arg
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | tTILDE arg
                     {
@@ -1001,7 +1001,7 @@ rule
                     }
                 | kBEGIN bodystmt kEND
                     {
-                      result = @builder.begin(val[0], val[1], val[2])
+                      result = @builder.begin_keyword(val[0], val[1], val[2])
                     }
                 | tLPAREN_ARG expr
                     {
@@ -1253,6 +1253,9 @@ rule
                 | tCOLON
                 | kTHEN
                 | term kTHEN
+                    {
+                      result = val[1]
+                    }
 
               do: term
                 | tCOLON
@@ -1611,7 +1614,7 @@ xstring_contents: # nothing
                       @lexer.cond.lexpop
                       @lexer.cmdarg.lexpop
 
-                      result = val[2]
+                      result = @builder.begin(val[0], val[2], val[3])
                     }
 
      string_dvar: tGVAR

data/lib/parser/ruby19.y

@@ -258,11 +258,11 @@ rule
                     }
                 | kNOT opt_nl expr
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], nil, val[2], nil)
                     }
                 | tBANG command_call
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | arg
 
@@ -777,7 +777,7 @@ rule
                     }
                 | arg tMATCH arg
                     {
-                      result = @builder.binary_op(val[0], val[1], val[2])
+                      result = @builder.match_op(val[0], val[1], val[2])
                     }
                 | arg tNMATCH arg
                     {
@@ -785,7 +785,7 @@ rule
                     }
                 | tBANG arg
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | tTILDE arg
                     {
@@ -954,7 +954,7 @@ rule
                     }
                 | kBEGIN bodystmt kEND
                     {
-                      result = @builder.begin(val[0], val[1], val[2])
+                      result = @builder.begin_keyword(val[0], val[1], val[2])
                     }
                 | tLPAREN_ARG expr
                     {
@@ -1007,11 +1007,11 @@ rule
                     }
                 | kNOT tLPAREN2 expr rparen
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], val[1], val[2], val[3])
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      result = @builder.not_op(val[0])
+                      result = @builder.not_op(val[0], val[1], nil, val[2])
                     }
                 | operation brace_block
                     {
@@ -1209,6 +1209,9 @@ rule
             then: term
                 | kTHEN
                 | term kTHEN
+                    {
+                      result = val[1]
+                    }
 
               do: term
                 | kDO_COND
@@ -1727,7 +1730,7 @@ regexp_contents: # nothing
                       @lexer.cond.lexpop
                       @lexer.cmdarg.lexpop
 
-                      result = val[2]
+                      result = @builder.begin(val[0], val[2], val[3])
                     }
 
      string_dvar: tGVAR

data/lib/parser/ruby20.y

@@ -269,11 +269,11 @@ rule
                     }
                 | kNOT opt_nl expr
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], nil, val[2], nil)
                     }
                 | tBANG command_call
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | arg
 
@@ -797,7 +797,7 @@ rule
                     }
                 | arg tMATCH arg
                     {
-                      result = @builder.binary_op(val[0], val[1], val[2])
+                      result = @builder.match_op(val[0], val[1], val[2])
                     }
                 | arg tNMATCH arg
                     {
@@ -805,7 +805,7 @@ rule
                     }
                 | tBANG arg
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | tTILDE arg
                     {
@@ -983,7 +983,7 @@ rule
                     {
                       @lexer.cmdarg = val[1]
 
-                      result = @builder.begin(val[0], val[2], val[3])
+                      result = @builder.begin_keyword(val[0], val[2], val[3])
                     }
                 | tLPAREN_ARG expr
                     {
@@ -1044,11 +1044,11 @@ rule
                     }
                 | kNOT tLPAREN2 expr rparen
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], val[1], val[2], val[3])
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      result = @builder.not_op(val[0])
+                      result = @builder.not_op(val[0], val[1], nil, val[2])
                     }
                 | fcall brace_block
                     {
@@ -1246,6 +1246,9 @@ rule
             then: term
                 | kTHEN
                 | term kTHEN
+                    {
+                      result = val[1]
+                    }
 
               do: term
                 | kDO_COND
@@ -1829,7 +1832,7 @@ regexp_contents: # nothing
                       @lexer.cond.lexpop
                       @lexer.cmdarg.lexpop
 
-                      result = val[2]
+                      result = @builder.begin(val[0], val[2], val[3])
                     }
 
      string_dvar: tGVAR

data/lib/parser/ruby21.y

@@ -264,11 +264,11 @@ rule
                     }
                 | kNOT opt_nl expr
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], nil, val[2], nil)
                     }
                 | tBANG command_call
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | arg
 
@@ -792,7 +792,7 @@ rule
                     }
                 | arg tMATCH arg
                     {
-                      result = @builder.binary_op(val[0], val[1], val[2])
+                      result = @builder.match_op(val[0], val[1], val[2])
                     }
                 | arg tNMATCH arg
                     {
@@ -800,7 +800,7 @@ rule
                     }
                 | tBANG arg
                     {
-                      result = @builder.not_op(val[0], val[1])
+                      result = @builder.not_op(val[0], nil, val[1], nil)
                     }
                 | tTILDE arg
                     {
@@ -984,7 +984,7 @@ rule
                     {
                       @lexer.cmdarg = val[1]
 
-                      result = @builder.begin(val[0], val[2], val[3])
+                      result = @builder.begin_keyword(val[0], val[2], val[3])
                     }
                 | tLPAREN_ARG expr
                     {
@@ -1045,11 +1045,11 @@ rule
                     }
                 | kNOT tLPAREN2 expr rparen
                     {
-                      result = @builder.not_op(val[0], val[2])
+                      result = @builder.not_op(val[0], val[1], val[2], val[3])
                     }
                 | kNOT tLPAREN2 rparen
                     {
-                      result = @builder.not_op(val[0])
+                      result = @builder.not_op(val[0], val[1], nil, val[2])
                     }
                 | fcall brace_block
                     {
@@ -1247,6 +1247,9 @@ rule
             then: term
                 | kTHEN
                 | term kTHEN
+                    {
+                      result = val[1]
+                    }
 
               do: term
                 | kDO_COND
@@ -1830,7 +1833,7 @@ regexp_contents: # nothing
                       @lexer.cond.lexpop
                       @lexer.cmdarg.lexpop
 
-                      result = val[2]
+                      result = @builder.begin(val[0], val[2], val[3])
                     }
 
      string_dvar: tGVAR

data/lib/parser/runner/ruby_parse.rb

@@ -7,13 +7,9 @@ module Parser
 
     class LocationProcessor < Parser::AST::Processor
       def process(node)
-        p node
+        if node
+          p node
 
-        if node.src.nil?
-          puts "\e[31m[no location info]\e[0m"
-        elsif node.src.expression.nil?
-          puts "\e[31m[location info present but empty]\e[0m"
-        else
           source_line_no = nil
           source_line    = ""
           hilight_line   = ""
@@ -33,7 +29,7 @@ module Parser
             source_line
           end
 
-          node.src.to_hash.
+          node.loc.to_hash.
             sort_by do |name, range|
               [(range ? range.line : 0),
                (name == :expression ? 1 : 0)]
@@ -112,11 +108,11 @@ module Parser
     end
 
     def process_all_input
-      super
-
       if input_size > 1
         puts "Using #{@parser_class} to parse #{input_size} files."
       end
+
+      super
     end
 
     def process(buffer)

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

@@ -47,6 +47,8 @@ module Parser
       end
 
       def current_comment_between?(prev_node, next_node)
+        return false if current_comment.nil?
+
         comment_loc = current_comment.location
         next_loc    = next_node.location.expression
 

data/lib/parser/version.rb

@@ -1,3 +1,3 @@
 module Parser
-  VERSION = '2.0.0.beta5'
+  VERSION = '2.0.0.beta6'
 end

data/parser.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency             'ast',       '~> 1.0'
+  spec.add_dependency             'ast',       '~> 1.1'
   spec.add_dependency             'slop',      '~> 3.4'
 
   spec.add_development_dependency 'bundler',   '~> 1.2'

data/test/test_lexer.rb

@@ -2565,6 +2565,14 @@ class TestLexer < Minitest::Test
                    :tNL,             nil)
   end
 
+  def test_bug_heredoc_lshft
+    util_lex_token("<<RULES << CLEANINGS\nRULES",
+                   :tSTRING_BEG, '"',
+                   :tSTRING_END, 'RULES',
+                   :tLSHFT,      '<<',
+                   :tCONSTANT,   'CLEANINGS')
+  end
+
   def test_bug_expr_dot_comment
     util_lex_token("foo. #bar\nbaz",
                    :tIDENTIFIER, 'foo',

data/test/test_parser.rb

@@ -42,7 +42,7 @@ class TestParser < Minitest::Test
 
   def test_empty_stmt
     assert_parses(
-      s(:nil),
+      nil,
       %q{})
   end
 
@@ -120,11 +120,14 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:dstr,
         s(:str, 'foo'),
-        s(:lvar, :bar),
+        s(:begin, s(:lvar, :bar)),
         s(:str, 'baz')),
       %q{"foo#{bar}baz"},
       %q{^ begin
         |             ^ end
+        |    ^^ begin (begin)
+        |         ^ end (begin)
+        |    ~~~~~~ expression (begin)
         |~~~~~~~~~~~~~~ expression})
   end
 
@@ -181,11 +184,14 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:dsym,
         s(:str, 'foo'),
-        s(:lvar, :bar),
+        s(:begin, s(:lvar, :bar)),
         s(:str, 'baz')),
       %q{:"foo#{bar}baz"},
       %q{^^ begin
         |              ^ end
+        |     ^^ begin (begin)
+        |          ^ end (begin)
+        |     ~~~~~~ expression (begin)
         |~~~~~~~~~~~~~~~ expression})
   end
 
@@ -218,11 +224,14 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:xstr,
         s(:str, 'foo'),
-        s(:lvar, :bar),
+        s(:begin, s(:lvar, :bar)),
         s(:str, 'baz')),
       %q{`foo#{bar}baz`},
       %q{^ begin
         |             ^ end
+        |    ^^ begin (begin)
+        |         ^ end (begin)
+        |    ~~~~~~ expression (begin)
         |~~~~~~~~~~~~~~ expression})
   end
 
@@ -242,11 +251,14 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:regexp,
         s(:str, 'foo'),
-        s(:lvar, :bar),
+        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
@@ -325,18 +337,24 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:array,
         s(:str, "foo"),
-        s(:dstr, s(:lvar, :bar))),
+        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.lvar)
+        |         ~~~ expression (dstr.begin.lvar)
         |~~~~~~~~~~~~~~ expression})
 
     assert_parses(
       s(:array,
         s(:str, "foo"),
-        s(:dstr, s(:lvar, :bar), s(:str, 'foo'), s(:ivar, :@baz))),
+        s(:dstr,
+          s(:begin, s(:lvar, :bar)),
+          s(:str, 'foo'),
+          s(:ivar, :@baz))),
       %q{%W[foo #{bar}foo#@baz]})
   end
 
@@ -368,17 +386,23 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:array,
         s(:sym, :foo),
-        s(:dsym, s(:lvar, :bar))),
+        s(:dsym, s(:begin, s(:lvar, :bar)))),
       %q{%I[foo #{bar}]},
       %q{^^^ begin
         |             ^ end
         |   ~~~ expression (sym)
-        |         ~~~ expression (dsym.lvar)
+        |       ^^ 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(:lvar, :bar))),
+      s(:array,
+        s(:dsym,
+          s(:str, "foo"),
+          s(:begin, s(:lvar, :bar)))),
       %q{%I[foo#{bar}]},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -1280,11 +1304,11 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:module,
         s(:const, nil, :Foo),
-        s(:nil)),
-      %q{module Foo; nil; end},
+        nil),
+      %q{module Foo; end},
       %q{~~~~~~ keyword
         |       ~~~ name
-        |                 ~~~ end})
+        |            ~~~ end})
   end
 
   def test_module_invalid
@@ -1297,20 +1321,20 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:module,
         s(:const, s(:cbase), :Foo),
-        s(:nil)),
-      %q{module ::Foo; nil; end})
+        nil),
+      %q{module ::Foo; end})
 
     assert_parses(
       s(:module,
         s(:const, s(:const, nil, :Bar), :Foo),
-        s(:nil)),
-      %q{module Bar::Foo; nil; end})
+        nil),
+      %q{module Bar::Foo; end})
   end
 
   def test_cpath_invalid
     assert_diagnoses(
       [:error, :module_name_const],
-      %q{module foo; nil; end})
+      %q{module foo; end})
   end
 
   def test_class
@@ -1318,11 +1342,11 @@ class TestParser < Minitest::Test
       s(:class,
         s(:const, nil, :Foo),
         nil,
-        s(:nil)),
-      %q{class Foo; nil; end},
+        nil),
+      %q{class Foo; end},
       %q{~~~~~ keyword
         |      ~~~ name
-        |                ~~~ end})
+        |           ~~~ end})
   end
 
   def test_class_super
@@ -1330,11 +1354,11 @@ class TestParser < Minitest::Test
       s(:class,
         s(:const, nil, :Foo),
         s(:const, nil, :Bar),
-        s(:nil)),
-      %q{class Foo < Bar; nil; end},
+        nil),
+      %q{class Foo < Bar; end},
       %q{~~~~~ keyword
         |          ^ operator
-        |                      ~~~ end})
+        |                 ~~~ end})
   end
 
   def test_class_super_label
@@ -1343,7 +1367,7 @@ class TestParser < Minitest::Test
         s(:const, nil, :Foo),
         s(:send, nil, :a,
           s(:sym, :b)),
-        s(:nil)),
+        nil),
       %q{class Foo < a:b; end},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -1372,50 +1396,50 @@ class TestParser < Minitest::Test
 
   def test_def
     assert_parses(
-      s(:def, :foo, s(:args), s(:nil)),
-      %q{def foo; nil; end},
+      s(:def, :foo, s(:args), nil),
+      %q{def foo; end},
       %q{~~~ keyword
         |    ~~~ name
-        |              ~~~ end})
+        |         ~~~ end})
 
     assert_parses(
-      s(:def, :String, s(:args), s(:nil)),
+      s(:def, :String, s(:args), nil),
       %q{def String; end})
 
     assert_parses(
-      s(:def, :String=, s(:args), s(:nil)),
+      s(:def, :String=, s(:args), nil),
       %q{def String=; end})
   end
 
   def test_defs
     assert_parses(
-      s(:defs, s(:self), :foo, s(:args), s(:nil)),
-      %q{def self.foo; nil; end},
+      s(:defs, s(:self), :foo, s(:args), nil),
+      %q{def self.foo; end},
       %q{~~~ keyword
         |        ^ operator
         |         ~~~ name
-        |                   ~~~ end})
+        |              ~~~ end})
 
     assert_parses(
-      s(:defs, s(:self), :foo, s(:args), s(:nil)),
-      %q{def self::foo; nil; end},
+      s(:defs, s(:self), :foo, s(:args), nil),
+      %q{def self::foo; end},
       %q{~~~ keyword
         |        ^^ operator
         |          ~~~ name
-        |                    ~~~ end})
+        |               ~~~ end})
 
     assert_parses(
-      s(:defs, s(:lvar, :foo), :foo, s(:args), s(:nil)),
+      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), s(:nil)),
+        s(:args), nil),
       %q{def String.foo; end})
 
     assert_parses(
       s(:defs, s(:const, nil, :String), :foo,
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{def String::foo; end})
   end
 
@@ -1466,7 +1490,7 @@ class TestParser < Minitest::Test
       s(:undef,
         s(:sym, :foo),
         s(:sym, :bar),
-        s(:dsym, s(:str, "foo"), s(:int, 1))),
+        s(:dsym, s(:str, "foo"), s(:begin, s(:int, 1)))),
       %q{undef foo, :bar, :"foo#{1}"},
       %q{~~~~~ keyword
         |      ~~~ expression (sym/1)
@@ -1862,7 +1886,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, nil, :f),
-        ast, s(:nil)),
+        ast, nil),
       %Q{f{ #{code} }},
       %q{},
       versions)
@@ -2246,7 +2270,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :foo,
         s(:args, s(:arg, :_), s(:arg, :_)),
-        s(:nil)),
+        nil),
       %q{def foo(_, _); end},
       %q{},
       ALL_VERSIONS - %w(1.8))
@@ -2260,7 +2284,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:def, :foo,
         s(:args, s(:arg, :_a), s(:arg, :_a)),
-        s(:nil)),
+        nil),
       %q{def foo(_a, _a); end},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -2336,19 +2360,19 @@ class TestParser < Minitest::Test
 
   def test_send_self_block
     assert_parses(
-      s(:block, s(:send, nil, :fun), s(:args), s(:nil)),
+      s(:block, s(:send, nil, :fun), s(:args), nil),
       %q{fun { }})
 
     assert_parses(
-      s(:block, s(:send, nil, :fun), s(:args), s(:nil)),
+      s(:block, s(:send, nil, :fun), s(:args), nil),
       %q{fun() { }})
 
     assert_parses(
-      s(:block, s(:send, nil, :fun, s(:int, 1)), s(:args), s(:nil)),
+      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), s(:nil)),
+      s(:block, s(:send, nil, :fun), s(:args), nil),
       %q{fun do end})
   end
 
@@ -2440,7 +2464,7 @@ class TestParser < Minitest::Test
       s(:send,
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil)),
+          s(:args), nil),
         :fun, s(:lvar, :bar)),
       %q{meth 1 do end.fun bar},
       %q{              ~~~ selector
@@ -2451,7 +2475,7 @@ class TestParser < Minitest::Test
       s(:send,
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil)),
+          s(:args), nil),
         :fun, s(:lvar, :bar)),
       %q{meth 1 do end.fun(bar)},
       %q{              ~~~ selector
@@ -2464,7 +2488,7 @@ class TestParser < Minitest::Test
       s(:send,
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil)),
+          s(:args), nil),
         :fun, s(:lvar, :bar)),
       %q{meth 1 do end::fun bar},
       %q{               ~~~ selector
@@ -2475,7 +2499,7 @@ class TestParser < Minitest::Test
       s(:send,
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil)),
+          s(:args), nil),
         :fun, s(:lvar, :bar)),
       %q{meth 1 do end::fun(bar)},
       %q{               ~~~ selector
@@ -2489,9 +2513,9 @@ class TestParser < Minitest::Test
         s(:send,
           s(:block,
             s(:send, nil, :meth, s(:int, 1)),
-            s(:args), s(:nil)),
+            s(:args), nil),
           :fun, s(:lvar, :bar)),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{meth 1 do end.fun bar do end},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -2501,9 +2525,9 @@ class TestParser < Minitest::Test
         s(:send,
           s(:block,
             s(:send, nil, :meth, s(:int, 1)),
-            s(:args), s(:nil)),
+            s(:args), nil),
           :fun, s(:lvar, :bar)),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{meth 1 do end.fun(bar) {}},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -2513,9 +2537,9 @@ class TestParser < Minitest::Test
         s(:send,
           s(:block,
             s(:send, nil, :meth, s(:int, 1)),
-            s(:args), s(:nil)),
+            s(:args), nil),
           :fun),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{meth 1 do end.fun {}},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -2526,7 +2550,7 @@ class TestParser < Minitest::Test
       s(:send, nil, :foo,
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil))),
+          s(:args), nil)),
       %q{foo(meth 1 do end)},
       %q{},
       %w(1.8))
@@ -2536,7 +2560,7 @@ class TestParser < Minitest::Test
         s(:int, 1),
         s(:block,
           s(:send, nil, :meth, s(:int, 1)),
-          s(:args), s(:nil))),
+          s(:args), nil)),
       %q{foo(1, meth 1 do end)},
       %q{},
       %w(1.8))
@@ -2710,7 +2734,7 @@ class TestParser < Minitest::Test
       ALL_VERSIONS - %w(1.8))
 
     assert_parses(
-      s(:send, s(:nil), :'!'),
+      s(:send, s(:begin), :'!'),
       %q{not()},
       %{},
       ALL_VERSIONS - %w(1.8))
@@ -2803,7 +2827,7 @@ class TestParser < Minitest::Test
   def test_send_lambda
     assert_parses(
       s(:block, s(:send, nil, :lambda),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{->{ }},
       %q{~~ selector (send)
         |  ^ begin
@@ -2813,7 +2837,7 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:block, s(:send, nil, :lambda),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{-> do end},
       %q{~~ selector (send)
         |   ^^ begin
@@ -2827,7 +2851,7 @@ class TestParser < Minitest::Test
       s(:block, s(:send, nil, :lambda),
         s(:args,
           s(:arg, :a)),
-        s(:nil)),
+        nil),
       %q{->(a) { }},
       %q{~~ selector (send)
         |  ^ begin (args)
@@ -2841,7 +2865,7 @@ class TestParser < Minitest::Test
       s(:block, s(:send, nil, :lambda),
         s(:args,
           s(:arg, :a)),
-        s(:nil)),
+        nil),
       %q{-> (a) { }},
       %q{},
       ALL_VERSIONS - %w(1.8 1.9))
@@ -2854,7 +2878,7 @@ class TestParser < Minitest::Test
           s(:arg, :a),
           s(:shadowarg, :foo),
           s(:shadowarg, :bar)),
-        s(:nil)),
+        nil),
       %q{->(a; foo, bar) { }},
       %q{      ~~~ expression (args.shadowarg)},
       ALL_VERSIONS - %w(1.8))
@@ -2882,6 +2906,32 @@ class TestParser < Minitest::Test
       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
@@ -3105,19 +3155,19 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, nil, :fun, s(:begin, s(:int, 1))),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{fun (1) {}})
 
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{foo.fun (1) {}})
 
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun, s(:begin, s(:int, 1))),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{foo::fun (1) {}})
   end
 
@@ -3342,7 +3392,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, nil, :fun),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{fun () {}},
       %q{    ^ begin (send)
         |     ^ end (send)},
@@ -3351,7 +3401,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{foo.fun () {}},
       %q{        ^ begin (send)
         |         ^ end (send)},
@@ -3360,7 +3410,7 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, s(:lvar, :foo), :fun),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{foo::fun () {}},
       %q{         ^ begin (send)
         |          ^ end (send)},
@@ -3369,10 +3419,10 @@ class TestParser < Minitest::Test
     assert_parses(
       s(:block,
         s(:send, nil, :fun,
-          s(:nil)),
-        s(:args), s(:nil)),
+          s(:begin)),
+        s(:args), nil),
       %q{fun () {}},
-      %q{    ~~ expression (send.nil)},
+      %q{    ~~ expression (send.begin)},
       ALL_VERSIONS - %w(1.8 1.9))
   end
 
@@ -3410,13 +3460,23 @@ class TestParser < Minitest::Test
         |~~~~~~~~~~ expression})
   end
 
-  def test_and_or_masgn_invalid
-    assert_diagnoses(
-      [:error, :masgn_as_condition],
+  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_diagnoses(
-      [:error, :masgn_as_condition],
+    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
 
@@ -3439,6 +3499,13 @@ class TestParser < Minitest::Test
         |~~~~~~~~~~~~~~~~ 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),
@@ -3554,10 +3621,56 @@ class TestParser < Minitest::Test
   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 (bar; a, b = foo); end},
-      %q{         ~~~~~~~~~~ location})
+      %q{if foo && (a, b = bar); end},
+      %q{           ~~~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :masgn_as_condition],
+      %q{if foo || (a, b = bar); end},
+      %q{           ~~~~~~~~~~ location})
+  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})
   end
 
   # Case matching
@@ -3659,7 +3772,7 @@ class TestParser < Minitest::Test
           s(:lvar, :bar)),
         s(:when,
           s(:splat, s(:lvar, :foo)),
-          s(:nil)),
+          nil),
         nil),
       %q{case foo; when 1, *baz; bar; when *foo; end},
       %q{                  ^ operator (when/1.splat)
@@ -3803,7 +3916,7 @@ class TestParser < Minitest::Test
         |~~~~~~~~~ expression})
 
     assert_parses(
-        s(:break, s(:nil)),
+        s(:break, s(:begin)),
       %q{break()},
       %q{~~~~~ keyword
         |~~~~~~~ expression},
@@ -3838,7 +3951,7 @@ class TestParser < Minitest::Test
         |~~~~~~~~~~ expression})
 
     assert_parses(
-      s(:return, s(:nil)),
+      s(:return, s(:begin)),
       %q{return()},
       %q{~~~~~~ keyword
         |~~~~~~~~ expression},
@@ -3873,7 +3986,7 @@ class TestParser < Minitest::Test
         |~~~~~~~~ expression})
 
     assert_parses(
-        s(:next, s(:nil)),
+        s(:next, s(:begin)),
       %q{next()},
       %q{~~~~ keyword
         |~~~~~~ expression},
@@ -3945,8 +4058,7 @@ class TestParser < Minitest::Test
   def test_ensure_empty
     assert_parses(
       s(:begin,
-        s(:ensure, s(:nil),
-          s(:nil))),
+        s(:ensure, nil, nil)),
       %q{begin ensure end},
       %q{~~~~~ begin
         |      ~~~~~~ keyword (ensure)
@@ -4280,23 +4392,23 @@ class TestParser < Minitest::Test
       s(:block,
         s(:send, nil, :desc,
           s(:str, "foo")),
-        s(:args), s(:nil)),
+        s(:args), nil),
       %q{desc "foo" do end})
   end
 
   def test_bug_interp_single
     assert_parses(
-      s(:dstr, s(:int, 1)),
+      s(:dstr, s(:begin, s(:int, 1))),
       %q{"#{1}"})
 
     assert_parses(
-      s(:array, s(:dstr, s(:int, 1))),
+      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), s(:nil)),
+      s(:def, :foo, s(:args), nil),
       %Q{def foo\n=begin\n=end\nend})
   end
 end