Adapt MRI tests to allow Prism error messages

* And exclude on missing SyntaxError.

Author: eregon

test/mri/excludes/TestParse.rb

@@ -50,3 +50,5 @@
 exclude :test_magic_comment, "<#<Encoding:US-ASCII>> expected but was"
 exclude :test_if_after_class, "/home/eregon/code/truffleruby-ws/truffleruby/test/mri/tests/ruby/test_parse.rb:1365:in `test_if_after_class'."
 exclude :test_escaped_space, "/home/eregon/code/truffleruby-ws/truffleruby/test/mri/tests/ruby/test_parse.rb:1370:in `test_escaped_space'."
+exclude :test_dynamic_constant_assignment, "prism"
+exclude :test_serial_comparison, "prism"

test/mri/excludes/TestRegexp.rb

@@ -50,3 +50,5 @@
 exclude :test_s_timeout_corner_cases, "NoMethodError: private method `timeout' called for Regexp:Class"
 exclude :test_bug_19467, "NoMethodError: undefined method `timeout=' for Regexp:Class"
 exclude :test_s_timeout, "NoMethodError: undefined method `timeout=' for Regexp:Class"
+exclude :test_unicode, "prism missing regexp encoding flags"
+exclude :test_char_class, "prism missing regexp encoding flags"

test/mri/excludes/TestRubyLiteral.rb

@@ -3,3 +3,4 @@
 exclude :test_hash_value_omission, "NameError: undefined local variable or method `FOO' for #<TestRubyLiteral:0x2914b8>"
 exclude :test_hash_duplicated_key, "duplicated literal key."
 exclude :test_float, "_1 inside eval, see https://github.com/ruby/prism/issues/2275"
+exclude :test_dregexp, "prism missing regexp encoding flags"

test/mri/tests/ruby/test_class.rb

@@ -308,7 +308,7 @@ def test_invalid_retry_from_class_definition
   end
 
   def test_invalid_return_from_class_definition
-    assert_syntax_error("class C; return; end", /Invalid return/)
+    assert_syntax_error("class C; return; end", /Invalid return|invalid `return`/)
   end
 
   def test_invalid_yield_from_class_definition

test/mri/tests/ruby/test_parse.rb

@@ -26,7 +26,7 @@ def test_else_without_rescue
   end
 
   def test_alias_backref
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /can't make alias/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /can't make alias|invalid argument being passed to `alias`/) do
       begin;
         alias $foo $1
       end;
@@ -84,7 +84,7 @@ class << o
     assert_equal([42, 42], [o.Foo, o.Bar])
     assert_equal([42, 42], [o::baz, o::qux])
 
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /Can't set variable|immutable variable as a write target/) do
       begin;
         $1 ||= t.foo 42
       end;
@@ -192,13 +192,13 @@ def foo
   end
 
   def test_class_module
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /must be CONSTANT/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /must be CONSTANT|expected a constant name/) do
       begin;
         class foo; end
       end;
     end
 
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /in method body/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /in method body|unexpected class definition in a method definition/) do
       begin;
         def foo
           class Foo; end
@@ -294,7 +294,7 @@ def foo(@@foo); end
       end;
     end
 
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /cannot be an instance variable|expected a local variable name in the block parameters/) do
       begin;
         o.foo {|; @a| @a = 42 }
       end;
@@ -377,10 +377,10 @@ def test_dsym
 
   def assert_disallowed_variable(type, noname, invalid)
     noname.each do |name|
-      assert_syntax_error("proc{a = #{name} }", "`#{noname[0]}' without identifiers is not allowed as #{type} variable name")
+      assert_syntax_error("proc{a = #{name} }", /`#{noname[0]}' without identifiers is not allowed as #{type} variable name|invalid global variable/)
     end
     invalid.each do |name|
-      assert_syntax_error("proc {a = #{name} }", "`#{name}' is not allowed as #{type} variable name")
+      assert_syntax_error("proc {a = #{name} }", /`#{name}' is not allowed as #{type} variable name|invalid global variable/)
     end
   end
 
@@ -438,13 +438,13 @@ def test_duplicate_argument
       end;
     end
 
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument|repeated parameter name/) do
       begin;
         1.times {|a, a|}
       end;
     end
 
-    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument/) do
+    assert_syntax_error("#{<<~"begin;"}\n#{<<~'end;'}", /duplicated argument|repeated parameter name/) do
       begin;
         def foo(a, a); end
       end;
@@ -611,12 +611,12 @@ def test_question
 
   def test_percent
     assert_equal(:foo, eval('%s(foo)'))
-    assert_syntax_error('%s', /unterminated quoted string/)
-    assert_syntax_error('%ss', /unknown type/)
-    assert_syntax_error('%z()', /unknown type/)
-    assert_syntax_error("%\u3042", /unknown type/)
-    assert_syntax_error("%q\u3042", /unknown type/)
-    assert_syntax_error("%", /unterminated quoted string/)
+    assert_syntax_error('%s', /unterminated quoted string|expected a closing delimiter for the dynamic symbol/)
+    assert_syntax_error('%ss', /unknown type|invalid `%` token/)
+    assert_syntax_error('%z()', /unknown type|invalid `%` token/)
+    assert_syntax_error("%\u3042", /unknown type|invalid `%` token/)
+    assert_syntax_error("%q\u3042", /unknown type|invalid `%` token/)
+    assert_syntax_error("%", /unterminated quoted string|invalid `%` token/)
   end
 
   def test_symbol
@@ -643,7 +643,7 @@ def test_symbol
   end
 
   def test_parse_string
-    assert_syntax_error("/\n", /unterminated/)
+    assert_syntax_error("/\n", /unterminated|expected a closing delimiter for the regular expression/)
   end
 
   def test_here_document
@@ -817,7 +817,7 @@ def test_block_dup
   end
 
   def test_set_backref
-    assert_syntax_error("$& = 1", /Can't set variable/)
+    assert_syntax_error("$& = 1", /Can't set variable|immutable variable as a write target/)
   end
 
   def test_arg_concat
@@ -1111,7 +1111,7 @@ def test_heredoc_interpolation
     end
 
   def test_unexpected_token_error
-    assert_syntax_error('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', /unexpected/)
+    assert_syntax_error('"x"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', /unexpected|expected a newline or semicolon after the statement/)
   end
 
   def test_unexpected_token_after_numeric
@@ -1129,7 +1129,7 @@ def test_truncated_source_line
   end
 
   def test_unterminated_regexp_error
-    e = assert_syntax_error("/x", /unterminated regexp meets end of file/)
+    e = assert_syntax_error("/x", /unterminated regexp meets end of file|expected a closing delimiter for the regular expression/)
     assert_not_match(/unexpected tSTRING_END/, e.message)
   end
 
@@ -1161,9 +1161,9 @@ def test_eof
   end
 
   def test_eof_in_def
-    assert_syntax_error("def m\n\0""end", /unexpected/)
-    assert_syntax_error("def m\n\C-d""end", /unexpected/)
-    assert_syntax_error("def m\n\C-z""end", /unexpected/)
+    assert_syntax_error("def m\n\0""end", /unexpected|cannot parse the expression/)
+    assert_syntax_error("def m\n\C-d""end", /unexpected|cannot parse the expression/)
+    assert_syntax_error("def m\n\C-z""end", /unexpected|cannot parse the expression/)
   end
 
   def test_unexpected_eof

test/mri/tests/ruby/test_require.rb

@@ -204,7 +204,7 @@ def assert_syntax_error_backtrace
     Dir.mktmpdir do |tmp|
       req = File.join(tmp, "test.rb")
       File.write(req, ",\n")
-      e = assert_raise_with_message(SyntaxError, /unexpected/) {
+      e = assert_raise_with_message(SyntaxError, /unexpected|cannot parse the expression/) {
         yield req
       }
       assert_not_nil(bt = e.backtrace, "no backtrace")
@@ -219,7 +219,7 @@ def test_require_syntax_error
 
   def test_require_syntax_error_rescued
     assert_syntax_error_backtrace do |req|
-      assert_raise_with_message(SyntaxError, /unexpected/) {require req}
+      assert_raise_with_message(SyntaxError, /unexpected|cannot parse the expression/) {require req}
       require req
     end
   end