Ensure CoreLibrary#{getMetaClass,getLogicalClass} is never used in PE code

Author: eregon

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

@@ -23,6 +23,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
+import com.oracle.truffle.api.CompilerAsserts;
 import com.oracle.truffle.api.object.Shape;
 import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.transcode.EConvFlags;
@@ -866,17 +867,17 @@ private void afterLoadCoreLibrary() {
                 .getValue();
     }
 
-    @TruffleBoundary
     public RubyClass getMetaClass(Object object) {
+        CompilerAsserts.neverPartOfCompilation("MetaClassNode should be used instead");
         if (object instanceof RubyDynamicObject) {
             return ((RubyDynamicObject) object).getMetaClass();
         } else {
             return getLogicalClass(object);
         }
     }
 
-    @TruffleBoundary
     public RubyClass getLogicalClass(Object object) {
+        CompilerAsserts.neverPartOfCompilation("LogicalClassNode should be used instead");
         if (object instanceof RubyDynamicObject) {
             return ((RubyDynamicObject) object).getLogicalClass();
         } else if (object instanceof Nil) {

src/main/java/org/truffleruby/core/cast/ToFNode.java

@@ -77,7 +77,7 @@ private double coerceObject(Object object, BranchProfile errorProfile) {
             }
         }
 
-        if (coreLibrary().getLogicalClass(coerced) == coreLibrary().floatClass) {
+        if (coerced instanceof Double) {
             return (double) coerced;
         } else {
             errorProfile.enter();

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -246,6 +246,7 @@ public RubyException argumentErrorInvalidBigDecimal(String string, Node currentN
         return argumentError(StringUtils.format("invalid value for BigDecimal(): \"%s\"", string), currentNode);
     }
 
+    @TruffleBoundary
     public RubyException argumentErrorCantUnfreeze(Object self, Node currentNode) {
         String className = context.getCoreLibrary().getLogicalClass(self).fields.getName();
         return argumentError(StringUtils.format("can't unfreeze %s", className), currentNode);

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -1311,7 +1311,8 @@ public GetMethodObjectNode(boolean ignoreVisibility) {
         @Specialization
         protected RubyMethod method(VirtualFrame frame, Object self, Object name,
                 @Cached ConditionProfile notFoundProfile,
-                @Cached ConditionProfile respondToMissingProfile) {
+                @Cached ConditionProfile respondToMissingProfile,
+                @Cached LogicalClassNode logicalClassNode) {
             final String normalizedName = nameToJavaStringNode.execute(name);
             InternalMethod method = lookupMethodNode
                     .lookup(frame, self, normalizedName, dispatchConfig);
@@ -1328,7 +1329,7 @@ protected RubyMethod method(VirtualFrame frame, Object self, Object name,
                             getContext(),
                             coreExceptions().nameErrorUndefinedMethod(
                                     normalizedName,
-                                    coreLibrary().getLogicalClass(self),
+                                    logicalClassNode.executeLogicalClass(self),
                                     this));
                 }
             }

src/main/java/org/truffleruby/core/string/StringNodes.java

@@ -307,10 +307,11 @@ public static SubstringNode create() {
         protected RubyString substring(Object source, int offset, int byteLength,
                 @CachedLibrary(limit = "2") RubyStringLibrary libSource,
                 @CachedLibrary(limit = "2") RubyLibrary library,
+                @Cached LogicalClassNode logicalClassNode,
                 @Cached AllocateHelperNode allocateHelperNode) {
             final Rope rope = libSource.getRope(source);
 
-            final RubyClass logicalClass = coreLibrary().getLogicalClass(source);
+            final RubyClass logicalClass = logicalClassNode.executeLogicalClass(source);
             final Shape shape = allocateHelperNode.getCachedShape(logicalClass);
             final RubyString string = new RubyString(
                     logicalClass,
@@ -386,9 +387,10 @@ protected RubyNode coerceToInteger(RubyNode times) {
 
         @Specialization(guards = "times == 0")
         protected RubyString multiplyZero(Object string, int times,
-                @CachedLibrary(limit = "2") RubyStringLibrary libString) {
+                @CachedLibrary(limit = "2") RubyStringLibrary libString,
+                @Cached LogicalClassNode logicalClassNode) {
 
-            final RubyClass logicalClass = coreLibrary().getLogicalClass(string);
+            final RubyClass logicalClass = logicalClassNode.executeLogicalClass(string);
             final Shape shape = allocateHelperNode.getCachedShape(logicalClass);
             final RubyString instance = new RubyString(
                     logicalClass,
@@ -5085,6 +5087,7 @@ public static abstract class StringSubstringPrimitiveNode extends CoreMethodArra
         @Child RopeNodes.CharacterLengthNode characterLengthNode = RopeNodes.CharacterLengthNode.create();
         @Child RopeNodes.SingleByteOptimizableNode singleByteOptimizableNode = RopeNodes.SingleByteOptimizableNode
                 .create();
+        @Child LogicalClassNode logicalClassNode = LogicalClassNode.create();
         @Child private RopeNodes.SubstringNode substringNode;
 
         public abstract Object execute(Object string, int index, int length);
@@ -5282,7 +5285,7 @@ private RubyString makeRope(Object string, Rope rope, int beg, int byteLength, b
                 substringNode = insert(RopeNodes.SubstringNode.create());
             }
 
-            final RubyClass logicalClass = coreLibrary().getLogicalClass(string);
+            final RubyClass logicalClass = logicalClassNode.executeLogicalClass(string);
             final Shape shape = allocateHelperNode.getCachedShape(logicalClass);
             final RubyString ret = new RubyString(
                     logicalClass,

src/main/java/org/truffleruby/interop/InteropNodes.java

@@ -54,6 +54,7 @@
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.dispatch.DispatchNode;
 import org.truffleruby.language.library.RubyStringLibrary;
+import org.truffleruby.language.objects.LogicalClassNode;
 import org.truffleruby.shared.TruffleRuby;
 
 import com.oracle.truffle.api.CallTarget;
@@ -1911,16 +1912,17 @@ public abstract static class InteropMetaObjectNode extends InteropCoreMethodArra
         @Specialization(limit = "getCacheLimit()")
         protected Object metaObject(Object value,
                 @CachedLibrary("value") InteropLibrary interop,
-                @Cached BranchProfile errorProfile) {
+                @Cached BranchProfile errorProfile,
+                @Cached LogicalClassNode logicalClassNode) {
             if (interop.hasMetaObject(value)) {
                 try {
                     return interop.getMetaObject(value);
                 } catch (UnsupportedMessageException e) {
                     errorProfile.enter();
-                    return coreLibrary().getLogicalClass(value);
+                    return logicalClassNode.executeLogicalClass(value);
                 }
             } else {
-                return coreLibrary().getLogicalClass(value);
+                return logicalClassNode.executeLogicalClass(value);
             }
         }
     }