[GR-16060] Define FrozenError and use it for can't modify frozen object exceptions.

PullRequest: truffleruby/862

Author: eregon

CHANGELOG.md

@@ -20,6 +20,7 @@ Compatibility
 * `String#-@` now performs string deduplication (#1608).
 * `Hash#merge` now preserves the key order from the original hash for merged values (#1650).
 * Coerce values given to `FFI::Pointer` methods.
+* `FrozenError` is now defined and is used for `can't modify frozen` object exceptions.
 
 Changes:
 

spec/ruby/core/kernel/autoload_spec.rb

@@ -57,7 +57,7 @@ def check_autoload(const)
   end
 
   describe "when Object is frozen" do
-    it "raises a FrozenError before defining the constant" do
+    it "raises a #{frozen_error_class} before defining the constant" do
       ruby_exe(fixture(__FILE__, "autoload_frozen.rb")).should == "#{frozen_error_class} - nil"
     end
   end

spec/tags/core/exception/standard_error_tags.txt

@@ -148,11 +148,6 @@ if MSpecScript.child_process?
   elsif ARGV.include? ":next"
     ::VersionGuard::FULL_RUBY_VERSION = SpecVersion.new("2.7.0")
   end
-
-  # We do not use Ruby 2.5's FrozenError yet
-  def frozen_error_class
-    RuntimeError
-  end
 end
 
 if i = ARGV.index('slow') and ARGV[i-1] == '--excl-tag' and MSpecScript.child_process?

spec/truffle.mspec

@@ -106,6 +106,7 @@ public class CoreLibrary {
     private final DynamicObjectFactory fiberFactory;
     private final DynamicObject floatClass;
     private final DynamicObject floatDomainErrorClass;
+    private final DynamicObject frozenErrorClass;
     private final DynamicObject hashClass;
     private final DynamicObjectFactory hashFactory;
     private final DynamicObject integerClass;
@@ -346,11 +347,14 @@ public CoreLibrary(RubyContext context) {
         ioErrorClass = defineClass(standardErrorClass, "IOError");
         localJumpErrorClass = defineClass(standardErrorClass, "LocalJumpError");
         regexpErrorClass = defineClass(standardErrorClass, "RegexpError");
-        runtimeErrorClass = defineClass(standardErrorClass, "RuntimeError");
         threadErrorClass = defineClass(standardErrorClass, "ThreadError");
         typeErrorClass = defineClass(standardErrorClass, "TypeError");
         zeroDivisionErrorClass = defineClass(standardErrorClass, "ZeroDivisionError");
 
+        // StandardError > RuntimeError
+        runtimeErrorClass = defineClass(standardErrorClass, "RuntimeError");
+        frozenErrorClass = defineClass(runtimeErrorClass, "FrozenError");
+
         // StandardError > RangeError
         rangeErrorClass = defineClass(standardErrorClass, "RangeError");
         floatDomainErrorClass = defineClass(rangeErrorClass, "FloatDomainError");
@@ -1305,6 +1309,10 @@ public DynamicObject getSyntaxErrorClass() {
         return syntaxErrorClass;
     }
 
+    public DynamicObject getFrozenErrorClass() {
+        return frozenErrorClass;
+    }
+
     public DynamicObject getFloatDomainErrorClass() {
         return floatDomainErrorClass;
     }

src/main/java/org/truffleruby/core/CoreLibrary.java

@@ -198,14 +198,23 @@ public DynamicObject argumentError(Rope message, Node currentNode, Throwable jav
         return ExceptionOperations.createRubyException(context, exceptionClass, StringOperations.createString(context, message), currentNode, javaThrowable);
     }
 
-    // RuntimeError
+    // FrozenError
 
     @TruffleBoundary
     public DynamicObject frozenError(Object object, Node currentNode) {
         String className = Layouts.MODULE.getFields(context.getCoreLibrary().getLogicalClass(object)).getName();
-        return runtimeError(StringUtils.format("can't modify frozen %s", className), currentNode);
+        return frozenError(StringUtils.format("can't modify frozen %s", className), currentNode);
+    }
+
+    @TruffleBoundary
+    public DynamicObject frozenError(String message, Node currentNode) {
+        DynamicObject exceptionClass = context.getCoreLibrary().getFrozenErrorClass();
+        DynamicObject errorMessage = StringOperations.createString(context, StringOperations.encodeRope(message, UTF8Encoding.INSTANCE));
+        return ExceptionOperations.createRubyException(context, exceptionClass, errorMessage, currentNode, null);
     }
 
+    // RuntimeError
+
     public DynamicObject runtimeErrorNotConstant(Node currentNode) {
         return runtimeError("Truffle::Graal.assert_constant can only be called lexically", currentNode);
     }