parser 2.4.0.2 → 2.5.0.0

data/test/test_lexer.rb

@@ -1,4 +1,5 @@
 # encoding: ascii-8bit
+# frozen_string_literal: true
 
 require 'helper'
 require 'complex'
@@ -22,11 +23,7 @@ class TestLexer < Minitest::Test
   #
 
   def utf(str)
-    if str.respond_to?(:force_encoding)
-      str.force_encoding(Encoding::UTF_8)
-    else
-      str
-    end
+    str.dup.force_encoding(Encoding::UTF_8)
   end
 
   #
@@ -42,20 +39,14 @@ class TestLexer < Minitest::Test
   def assert_escape(expected, input)
     source_buffer = Parser::Source::Buffer.new('(assert_escape)')
 
-    if defined?(Encoding)
-      source_buffer.source = "\"\\#{input}\"".encode(input.encoding)
-    else
-      source_buffer.source = "\"\\#{input}\""
-    end
+    source_buffer.source = "\"\\#{input}\"".encode(input.encoding)
 
     @lex.reset
     @lex.source_buffer = source_buffer
 
     lex_token, (lex_value, *) = @lex.advance
 
-    if lex_value.respond_to?(:force_encoding)
-      lex_value.force_encoding(Encoding::BINARY)
-    end
+    lex_value.force_encoding(Encoding::BINARY)
 
     assert_equal [:tSTRING, expected],
                  [lex_token, lex_value],
@@ -156,23 +147,19 @@ class TestLexer < Minitest::Test
   end
 
   def test_read_escape_unicode__19
-    if RUBY_VERSION >= '1.9'
-      assert_escape "\x09", 'u{9}'
-      assert_escape "\x31", 'u{31}'
-      assert_escape "\x09\x01", 'u{9 1}'
+    assert_escape "\x09", 'u{9}'
+    assert_escape "\x31", 'u{31}'
+    assert_escape "\x09\x01", 'u{9 1}'
 
-      assert_escape "\xc4\xa3", utf('u0123')
-      assert_escape "\xc4\xa3\xc3\xb0\xeb\x84\xa3", utf('u{123 f0 B123}')
-    end
+    assert_escape "\xc4\xa3", utf('u0123')
+    assert_escape "\xc4\xa3\xc3\xb0\xeb\x84\xa3", utf('u{123 f0 B123}')
   end
 
   def test_read_escape_unicode_bad__19
-    if RUBY_VERSION >= '1.9'
-      refute_escape 'u123'
-      refute_escape 'u{}'
-      refute_escape 'u{123 f0h}'
-      refute_escape 'u{123 f0'
-    end
+    refute_escape 'u123'
+    refute_escape 'u{}'
+    refute_escape 'u{123 f0h}'
+    refute_escape 'u{123 f0'
   end
 
   def test_ambiguous_uminus
@@ -974,6 +961,34 @@ class TestLexer < Minitest::Test
                    :tNL,             nil,          [8, 9])
   end
 
+  def test_heredoc_with_identifier_ending_newline__19
+    setup_lexer 19
+    refute_scanned "<<\"EOS\n\"\n123\nEOS\n"
+  end
+
+  def test_heredoc_with_identifier_ending_newline__24
+    setup_lexer 24
+
+    assert_scanned("a = <<\"EOS\n\"\nABCDEF\nEOS\n",
+                   :tIDENTIFIER,     "a",          [0, 1],
+                   :tEQL,            "=",          [2, 3],
+                   :tSTRING_BEG,     "<<\"",       [4, 12],
+                   :tSTRING_CONTENT, "ABCDEF\n",   [13, 20],
+                   :tSTRING_END,     "EOS",        [20, 23],
+                   :tNL,             nil,          [12, 13])
+  end
+
+  def test_heredoc_with_identifier_containing_newline_inside__19
+    setup_lexer 19
+    refute_scanned "<<\"EOS\nEOS\"\n123\nEOS\n"
+  end
+
+  def test_heredoc_with_identifier_containing_newline_inside__24
+    setup_lexer 24
+
+    refute_scanned "<<\"EOS\nEOS\"\n123\nEOS\n"
+  end
+
   def test_identifier
     assert_scanned("identifier",
                    :tIDENTIFIER, "identifier", [0, 10])
@@ -1171,20 +1186,16 @@ class TestLexer < Minitest::Test
   end
 
   def test_question_eh_escape_u_4_digits
-    if RUBY_VERSION >= '1.9'
-      setup_lexer 19
-      assert_scanned '?\\u0001', :tCHARACTER, "\u0001", [0, 7]
-    end
+    setup_lexer 19
+    assert_scanned '?\\u0001', :tCHARACTER, "\u0001", [0, 7]
   end
 
   def test_question_eh_single_unicode_point
-    if RUBY_VERSION >= '1.9'
-      setup_lexer 19
-      assert_scanned '?\\u{123}', :tCHARACTER, "\u0123", [0, 8]
+    setup_lexer 19
+    assert_scanned '?\\u{123}', :tCHARACTER, "\u0123", [0, 8]
 
-      setup_lexer 19
-      assert_scanned '?\\u{a}',  :tCHARACTER, "\n", [0, 6]
-    end
+    setup_lexer 19
+    assert_scanned '?\\u{a}',  :tCHARACTER, "\n", [0, 6]
   end
 
   def test_question_eh_multiple_unicode_points
@@ -1201,6 +1212,46 @@ class TestLexer < Minitest::Test
     refute_scanned '?\\u{123'
   end
 
+  def test_question_eh_escape_space_around_unicode_point__19
+    setup_lexer 19
+    refute_scanned '"\\u{1 }"'
+
+    setup_lexer 19
+    refute_scanned '"\\u{ 1}"'
+
+    setup_lexer 19
+    refute_scanned '"\\u{ 1 }"'
+
+    setup_lexer 19
+    refute_scanned '"\\u{1 2 }"'
+
+    setup_lexer 19
+    refute_scanned '"\\u{ 1 2}"'
+
+    setup_lexer 19
+    refute_scanned '"\\u{1  2}"'
+  end
+
+  def test_question_eh_escape_space_around_unicode_point__24
+    setup_lexer 24
+    assert_scanned '"\\u{ 1}"', :tSTRING, "\u0001", [0, 8]
+
+    setup_lexer 24
+    assert_scanned '"\\u{1 }"', :tSTRING, "\u0001", [0, 8]
+
+    setup_lexer 24
+    assert_scanned '"\\u{ 1 }"', :tSTRING, "\u0001", [0, 9]
+
+    setup_lexer 24
+    assert_scanned '"\\u{1 2 }"', :tSTRING, "\u0001\u0002", [0, 10]
+
+    setup_lexer 24
+    assert_scanned '"\\u{ 1 2}"', :tSTRING, "\u0001\u0002", [0, 10]
+
+    setup_lexer 24
+    assert_scanned '"\\u{1  2}"', :tSTRING, "\u0001\u0002", [0, 10]
+  end
+
   def test_integer_hex
     assert_scanned "0x2a", :tINTEGER, 42, [0, 4]
   end
@@ -2836,19 +2887,17 @@ class TestLexer < Minitest::Test
   # Handling of encoding-related issues.
   #
 
-  if defined?(Encoding)
-    def test_transcoded_source_is_converted_back_to_original_encoding
-      setup_lexer(19)
-      @lex.force_utf32 = true
-      @lex.tokens = []
-      assert_scanned(utf('"a" + "b"'),
-                     :tSTRING, "a", [0, 3],
-                     :tPLUS,   "+", [4, 5],
-                     :tSTRING, "b", [6, 9])
-
-      @lex.tokens.each do |_type, (str, _range)|
-        assert_equal Encoding::UTF_8, str.encoding
-      end
+  def test_transcoded_source_is_converted_back_to_original_encoding
+    setup_lexer(19)
+    @lex.force_utf32 = true
+    @lex.tokens = []
+    assert_scanned(utf('"a" + "b"'),
+                   :tSTRING, "a", [0, 3],
+                   :tPLUS,   "+", [4, 5],
+                   :tSTRING, "b", [6, 9])
+
+    @lex.tokens.each do |_type, (str, _range)|
+      assert_equal Encoding::UTF_8, str.encoding
     end
   end
 
@@ -3286,21 +3335,17 @@ class TestLexer < Minitest::Test
     assert_scanned(%q{"\xE2\x80\x99"},
                    :tSTRING, "\xE2\x80\x99", [0, 14])
 
-    if defined?(Encoding)
-      assert_scanned(utf(%q{"\xE2\x80\x99"}),
-                     :tSTRING, utf('’'), [0, 14])
-      assert_scanned(utf(%q{"\342\200\231"}),
-                     :tSTRING, utf('’'), [0, 14])
-      assert_scanned(utf(%q{"\M-b\C-\M-@\C-\M-Y"}),
-                     :tSTRING, utf('’'), [0, 20])
-    end
+    assert_scanned(utf(%q{"\xE2\x80\x99"}),
+                   :tSTRING, utf('’'), [0, 14])
+    assert_scanned(utf(%q{"\342\200\231"}),
+                   :tSTRING, utf('’'), [0, 14])
+    assert_scanned(utf(%q{"\M-b\C-\M-@\C-\M-Y"}),
+                   :tSTRING, utf('’'), [0, 20])
   end
 
   def test_bug_string_utf_escape_noop
-    if defined?(Encoding)
-      assert_scanned(utf(%q{"\あ"}),
-                     :tSTRING, utf("あ"), [0, 4])
-    end
+    assert_scanned(utf(%q{"\あ"}),
+                   :tSTRING, utf("あ"), [0, 4])
   end
 
   def test_bug_string_non_utf
@@ -3309,10 +3354,8 @@ class TestLexer < Minitest::Test
     assert_scanned(%Q{"caf\xC3\xA9"},
                    :tSTRING, "caf\xC3\xA9", [0, 7])
 
-    if defined?(Encoding)
-      assert_scanned(utf(%q{"café"}),
-                     :tSTRING, utf("café"), [0, 6])
-    end
+    assert_scanned(utf(%q{"café"}),
+                   :tSTRING, utf("café"), [0, 6])
   end
 
   def test_bug_semi__END__
@@ -3383,19 +3426,17 @@ class TestLexer < Minitest::Test
                    :kIF_MOD,  'if', [3, 5])
   end
 
-  if defined?(Encoding)
-    def test_bug_unicode_in_literal
-      setup_lexer(19)
-      assert_scanned('"\u00a4"',
-                     :tSTRING, "\u00a4", [0, 8])
-    end
+  def test_bug_unicode_in_literal
+    setup_lexer(19)
+    assert_scanned('"\u00a4"',
+                   :tSTRING, "\u00a4", [0, 8])
+  end
 
-    def test_bug_utf32le_leak
-      setup_lexer(19)
-      @lex.force_utf32 = true
-      assert_scanned('"F0"',
-                     :tSTRING, "F0", [0, 4])
-    end
+  def test_bug_utf32le_leak
+    setup_lexer(19)
+    @lex.force_utf32 = true
+    assert_scanned('"F0"',
+                   :tSTRING, "F0", [0, 4])
   end
 
   def test_bug_ragel_stack
@@ -3411,4 +3452,50 @@ class TestLexer < Minitest::Test
                    :tSTRING_END,      "\"",  [15, 16])
   end
 
+  def test_bug_423
+    @lex.state = :expr_beg
+    assert_scanned(':&&',
+                   :tSYMBEG, ':',  [0, 1],
+                   :tANDOP,  '&&', [1, 3])
+
+    @lex.state = :expr_beg
+    assert_scanned(':||',
+                   :tSYMBEG, ':',  [0, 1],
+                   :tOROP,   '||', [1, 3])
+  end
+
+  def test_bug_418
+    setup_lexer 19
+
+    assert_scanned("{\n=begin\nx: 1,\n=end\ny: 2}",
+                   :tLBRACE,  '{', [0, 1],
+                   :tLABEL,   'y', [20, 22],
+                   :tINTEGER, 2,   [23, 24],
+                   :tRCURLY,  '}', [24, 25])
+  end
+
+  def test_bug_407
+    setup_lexer(21)
+
+    assert_scanned('123if cond',
+                   :tINTEGER,    123,    [0, 3],
+                   :kIF_MOD,     'if',   [3, 5],
+                   :tIDENTIFIER, 'cond', [6, 10])
+
+    assert_scanned('1.23if cond',
+                   :tFLOAT,      1.23,   [0, 4],
+                   :kIF_MOD,     'if',   [4, 6],
+                   :tIDENTIFIER, 'cond', [7, 11])
+
+    assert_scanned('123rescue cond',
+                   :tINTEGER,    123,      [0, 3],
+                   :kRESCUE_MOD, 'rescue', [3, 9],
+                   :tIDENTIFIER, 'cond',   [10, 14])
+
+    assert_scanned('1.23rescue cond',
+                   :tFLOAT,      1.23,     [0, 4],
+                   :kRESCUE_MOD, 'rescue', [4, 10],
+                   :tIDENTIFIER, 'cond',   [11, 15])
+  end
+
 end

data/test/test_lexer_stack_state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 
 class TestLexerStackState < Minitest::Test

data/test/test_parse_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'helper'
 require 'parse_helper'
 
@@ -8,16 +10,14 @@ class TestParseHelper < Minitest::Test
     assert_instance_of Parser::Ruby18,
                        parser_for_ruby_version('1.8')
 
-    unless RUBY_VERSION == '1.8.7'
-      assert_instance_of Parser::Ruby19,
-                         parser_for_ruby_version('1.9')
+    assert_instance_of Parser::Ruby19,
+                       parser_for_ruby_version('1.9')
 
-      assert_instance_of Parser::Ruby20,
-                         parser_for_ruby_version('2.0')
+    assert_instance_of Parser::Ruby20,
+                       parser_for_ruby_version('2.0')
 
-      assert_instance_of Parser::Ruby21,
-                         parser_for_ruby_version('2.1')
-    end
+    assert_instance_of Parser::Ruby21,
+                       parser_for_ruby_version('2.1')
   end
 
   def parse_maps(what)

data/test/test_parser.rb

@@ -1,4 +1,5 @@
-# encoding:utf-8
+# encoding: utf-8
+# frozen_string_literal: true
 
 require 'helper'
 require 'parse_helper'
@@ -1102,6 +1103,21 @@ class TestParser < Minitest::Test
       [:error, :dynamic_const],
       %q{def f; ::Bar = 1; end},
       %q{       ~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def self.f; Foo = 1; end},
+      %q{            ~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def self.f; Foo::Bar = 1; end},
+      %q{            ~~~~~~~~ location})
+
+    assert_diagnoses(
+      [:error, :dynamic_const],
+      %q{def self.f; ::Bar = 1; end},
+      %q{            ~~~~~ location})
   end
 
   # Multiple assignment
@@ -1732,6 +1748,11 @@ class TestParser < Minitest::Test
       [:error, :class_in_def],
       %q{def a; class Foo; end; end},
       %q{       ^^^^^ location})
+
+    assert_diagnoses(
+      [:error, :class_in_def],
+      %q{def self.a; class Foo; end; end},
+      %q{            ^^^^^ location})
   end
 
   def test_sclass
@@ -5204,39 +5225,37 @@ class TestParser < Minitest::Test
     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_bom
+    assert_parses(
+      s(:int, 1),
+      %Q{\xef\xbb\xbf1}.dup.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_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}.dup.
+        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),
-        %{},
-        SINCE_1_9)
-    end
+  def test_regexp_encoding
+    assert_parses(
+      s(:match_with_lvasgn,
+        s(:regexp,
+          s(:str, "\\xa8"),
+          s(:regopt, :n)),
+        s(:str, "")),
+      %q{/\xa8/n =~ ""}.dup.force_encoding(Encoding::UTF_8),
+      %{},
+      SINCE_1_9)
   end
 
   #
@@ -5460,25 +5479,23 @@ class TestParser < Minitest::Test
   end
 
   def test_bug_ascii_8bit_in_literal
-    if defined?(Encoding)
-      assert_diagnoses(
-        [:error, :invalid_encoding],
-        %q{".\xc3."},
-        %q{^^^^^^^^ location},
-        ALL_VERSIONS)
-
-      assert_diagnoses(
-        [:error, :invalid_encoding],
-        %q{%W"x .\xc3."},
-        %q{     ^^^^^^ location},
-        ALL_VERSIONS)
-
-      assert_diagnoses(
-        [:error, :invalid_encoding],
-        %q{:".\xc3."},
-        %q{  ^^^^^^ location},
-        ALL_VERSIONS)
-    end
+    assert_diagnoses(
+      [:error, :invalid_encoding],
+      %q{".\xc3."},
+      %q{^^^^^^^^ location},
+      ALL_VERSIONS)
+
+    assert_diagnoses(
+      [:error, :invalid_encoding],
+      %q{%W"x .\xc3."},
+      %q{     ^^^^^^ location},
+      ALL_VERSIONS)
+
+    assert_diagnoses(
+      [:error, :invalid_encoding],
+      %q{:".\xc3."},
+      %q{  ^^^^^^ location},
+      ALL_VERSIONS)
 
     assert_diagnoses(
       [:error, :invalid_encoding],
@@ -5969,6 +5986,170 @@ class TestParser < Minitest::Test
       %q{    ^^^^^^ location})
   end
 
+  def test_ruby_bug_11873
+    # strings
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c, s(:send, nil, :d))),
+          s(:str, "x")),
+        s(:args),
+        nil),
+      %q{a b{c d}, "x" do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:str, "x")),
+        s(:args),
+        nil),
+      %q{a b(c d), "x" do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:str, "x")),
+        s(:args), nil),
+      %q{a b{c(d)}, "x" do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:str, "x")),
+        s(:args), nil),
+      %q{a b(c(d)), "x" do end},
+      %q{},
+      SINCE_2_4)
+
+    # regexps without options
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c, s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt))),
+        s(:args),
+        nil),
+      %q{a b{c d}, /x/ do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt))),
+        s(:args),
+        nil),
+      %q{a b(c d), /x/ do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt))),
+        s(:args), nil),
+      %q{a b{c(d)}, /x/ do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt))),
+        s(:args), nil),
+      %q{a b(c(d)), /x/ do end},
+      %q{},
+      SINCE_2_4)
+
+    # regexps with options
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c, s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt, :m))),
+        s(:args),
+        nil),
+      %q{a b{c d}, /x/m do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt, :m))),
+        s(:args),
+        nil),
+      %q{a b(c d), /x/m do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:block,
+            s(:send, nil, :b),
+            s(:args),
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt, :m))),
+        s(:args), nil),
+      %q{a b{c(d)}, /x/m do end},
+      %q{},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send, nil, :a,
+          s(:send, nil, :b,
+            s(:send, nil, :c,
+              s(:send, nil, :d))),
+          s(:regexp, s(:str, "x"), s(:regopt, :m))),
+        s(:args), nil),
+      %q{a b(c(d)), /x/m do end},
+      %q{},
+      SINCE_2_4)
+  end
+
   def test_parser_bug_198
     assert_parses(
       s(:array,
@@ -6021,4 +6202,385 @@ class TestParser < Minitest::Test
       s(:regexp, s(:str, "#)"), s(:regopt, :x)),
       %Q{/#)/x})
   end
+
+  def test_bug_do_block_in_hash_brace
+    assert_parses(
+      s(:send, nil, :p,
+        s(:sym, :foo),
+        s(:hash,
+          s(:pair,
+            s(:sym, :a),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)),
+          s(:pair,
+            s(:sym, :b),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)))),
+      %q{p :foo, {a: proc do end, b: proc do end}},
+      %q{},
+      SINCE_2_3)
+
+    assert_parses(
+      s(:send, nil, :p,
+        s(:sym, :foo),
+        s(:hash,
+          s(:pair,
+            s(:sym, :a),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)),
+          s(:pair,
+            s(:sym, :b),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)))),
+      %q{p :foo, {:a => proc do end, b: proc do end}},
+      %q{},
+      SINCE_2_3)
+
+    assert_parses(
+      s(:send, nil, :p,
+        s(:sym, :foo),
+        s(:hash,
+          s(:pair,
+            s(:sym, :a),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)),
+          s(:pair,
+            s(:sym, :b),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)))),
+      %q{p :foo, {"a": proc do end, b: proc do end}},
+      %q{},
+      SINCE_2_3)
+
+    assert_parses(
+      s(:send, nil, :p,
+        s(:sym, :foo),
+        s(:hash,
+          s(:pair,
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)),
+          s(:pair,
+            s(:sym, :b),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)))),
+      %q{p :foo, {proc do end => proc do end, b: proc do end}},
+      %q{},
+      SINCE_2_3)
+
+    assert_parses(
+      s(:send, nil, :p,
+        s(:sym, :foo),
+        s(:hash,
+          s(:kwsplat,
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)),
+          s(:pair,
+            s(:sym, :b),
+            s(:block,
+              s(:send, nil, :proc),
+              s(:args), nil)))),
+      %q{p :foo, {** proc do end, b: proc do end}},
+      %q{},
+      SINCE_2_3)
+  end
+
+  def test_lparenarg_after_lvar__since_25
+    assert_parses(
+      s(:send, nil, :meth,
+        s(:send,
+          s(:begin,
+            s(:float, -1.3)), :abs)),
+      %q{meth (-1.3).abs},
+      %q{},
+      ALL_VERSIONS - SINCE_2_5)
+
+    assert_parses(
+      s(:send,
+        s(:send, nil, :foo,
+          s(:float, -1.3)), :abs),
+      %q{foo (-1.3).abs},
+      %q{},
+      ALL_VERSIONS - SINCE_2_5)
+
+    assert_parses(
+      s(:send, nil, :meth,
+        s(:send,
+          s(:begin,
+            s(:float, -1.3)), :abs)),
+      %q{meth (-1.3).abs},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:send, nil, :foo,
+        s(:send,
+          s(:begin,
+            s(:float, -1.3)), :abs)),
+      %q{foo (-1.3).abs},
+      %q{},
+      SINCE_2_5)
+  end
+
+  def test_context_class
+    [
+      %q{class A;},
+      %q{class A < B;}
+    ].each do |code|
+      assert_context([:class], code, ALL_VERSIONS)
+    end
+  end
+
+  def test_context_sclass
+    assert_context(
+      [:sclass],
+      %q{class << foo;},
+      ALL_VERSIONS)
+  end
+
+  def test_context_def
+    assert_context(
+      [:def],
+      %q{def m;},
+      ALL_VERSIONS)
+  end
+
+  def test_context_defs
+    assert_context(
+      [:defs],
+      %q{def foo.m;},
+      ALL_VERSIONS)
+  end
+
+  def test_context_cmd_brace_block
+    [
+      'tap 1, { 1 => 2 } {',
+      'foo.tap 1, { 1 => 2 } {',
+      'foo::tap 1, { 1 => 2 } {'
+    ].each do |code|
+      assert_context([:block], code, ALL_VERSIONS)
+    end
+  end
+
+  def test_context_brace_block
+    [
+      'tap {',
+      'foo.tap {',
+      'foo::tap {',
+      'tap do',
+      'foo.tap do',
+      'foo::tap do'
+    ].each do |code|
+      assert_context([:block], code, ALL_VERSIONS)
+    end
+  end
+
+  def test_context_do_block
+    [
+      %q{tap 1 do},
+      %q{foo.tap do},
+      %q{foo::tap do}
+    ].each do |code|
+      assert_context([:block], code, ALL_VERSIONS)
+    end
+  end
+
+  def test_context_lambda
+    [
+      '->() {',
+      '->() do'
+    ].each do |code|
+      assert_context([:lambda], code, SINCE_1_9)
+    end
+  end
+
+  def test_context_nested
+    assert_context(
+      [:class, :sclass, :defs, :def, :block],
+      %q{class A; class << foo; def bar.m; def m; tap do},
+      ALL_VERSIONS)
+
+    assert_context(
+      [:class, :sclass, :defs, :def, :lambda, :block],
+      %q{class A; class << foo; def bar.m; def m; -> do; tap do},
+      SINCE_1_9)
+
+    assert_context(
+      [],
+      %q{
+        class A
+          class << foo
+            def bar.m
+              def m
+                tap do
+                end
+              end
+            end
+          end
+        end
+      },
+      ALL_VERSIONS)
+
+    assert_context(
+      [],
+      %q{
+        class A
+          class << foo
+            def bar.m
+              def m
+                -> do
+                  tap do
+                  end
+                end
+              end
+            end
+          end
+        end
+      },
+      SINCE_1_9)
+  end
+
+  def test_return_in_class
+    assert_parses(
+      s(:class,
+        s(:const, nil, :A), nil,
+        s(:return)),
+      %q{class A; return; end},
+      %q{},
+      ALL_VERSIONS - SINCE_2_5)
+
+    assert_diagnoses(
+      [:error, :invalid_return, {}],
+      %q{class A; return; end},
+      %q{         ^^^^^^ location},
+      SINCE_2_5)
+
+    [
+      %q{class << foo; return; end},
+      %q{def m; return; end},
+      %q{tap { return }},
+      %q{class A; class << self; return; end; end},
+      %q{class A; def m; return; end; end},
+    ].each do |code|
+      refute_diagnoses(code, ALL_VERSIONS)
+    end
+
+    [
+      %q{-> do return end},
+      %q{class A; -> do return end; end},
+    ].each do |code|
+      refute_diagnoses(code, SINCE_1_9)
+    end
+  end
+
+  def test_ruby_bug_13547
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m "x" {}},
+      %q{      ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m "#{'x'}" {}},
+      %q{           ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 1 {}},
+      %q{    ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 1.0 {}},
+      %q{      ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 1r {}},
+      %q{     ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 1i {}},
+      %q{     ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m :m {}},
+      %q{     ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m :"#{m}" {}},
+      %q{          ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m %[] {}},
+      %q{      ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 0..1 {}},
+      %q{       ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m 0...1 {}},
+      %q{        ^ location},
+      SINCE_2_4)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'tLCURLY' }],
+      %q{m [] {}},
+      %q{     ^ location},
+      SINCE_2_4)
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:send, nil, :meth), :[]),
+        s(:args), nil),
+      %q{meth[] {}},
+      %q{},
+      SINCE_2_4
+    )
+
+    assert_diagnoses_many(
+      [
+        [:warning, :ambiguous_literal],
+        [:error, :unexpected_token, { :token => 'tLCURLY' }]
+      ],
+      %q{m /foo/ {}},
+      SINCE_2_4)
+
+    assert_diagnoses_many(
+      [
+        [:warning, :ambiguous_literal],
+        [:error, :unexpected_token, { :token => 'tLCURLY' }]
+      ],
+      %q{m /foo/x {}},
+      SINCE_2_4)
+  end
 end