Convert FreezeNode to DSL inlinable

Author: horakivo

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

@@ -588,7 +588,7 @@ protected static RubyDynamicObject copyable(Object object, Object freeze,
 
             // Default behavior - is just to copy the frozen state of the original object
             if (forceFrozen(freeze) || (copyFrozen && isFrozenNode.execute(object))) { // Profiled through lazy usage of rubyLibraryFreeze
-                freezeNode.execute(newObject);
+                freezeNode.execute(node, newObject);
             }
 
             return newObject;

src/main/java/org/truffleruby/core/support/TypeNodes.java

@@ -120,7 +120,7 @@ public abstract static class ObjectFreezeNode extends RubyBaseNode {
         @Specialization(guards = "!isRubyDynamicObject(self)")
         protected Object freeze(Object self,
                 @Cached @Exclusive FreezeNode freezeNode) {
-            freezeNode.execute(self);
+            freezeNode.execute(this, self);
             return self;
         }
 
@@ -129,23 +129,24 @@ protected Object freezeNormalObject(RubyDynamicObject self,
                 @Cached @Shared FreezeNode freezeNode,
                 @Cached @Shared MetaClassNode metaClassNode,
                 @Bind("metaClassNode.execute(this, self)") RubyClass metaClass) {
-            freezeNode.execute(self);
+            freezeNode.execute(this, self);
             return self;
         }
 
         @Specialization(guards = "metaClass.isSingleton", limit = "1")
-        protected Object freezeSingletonObject(RubyDynamicObject self,
+        protected static Object freezeSingletonObject(RubyDynamicObject self,
                 @Cached @Shared FreezeNode freezeNode,
                 @Cached @Exclusive FreezeNode freezeMetaClasNode,
                 @Cached IsFrozenNode isFrozenMetaClassNode,
                 @Cached InlinedConditionProfile singletonClassUnfrozenProfile,
                 @Cached @Shared MetaClassNode metaClassNode,
-                @Bind("metaClassNode.execute(this, self)") RubyClass metaClass) {
-            if (singletonClassUnfrozenProfile.profile(this,
+                @Bind("metaClassNode.execute(this, self)") RubyClass metaClass,
+                @Bind("this") Node node) {
+            if (singletonClassUnfrozenProfile.profile(node,
                     !RubyGuards.isSingletonClass(self) && !isFrozenMetaClassNode.execute(metaClass))) {
-                freezeMetaClasNode.execute(metaClass);
+                freezeMetaClasNode.execute(node, metaClass);
             }
-            freezeNode.execute(self);
+            freezeNode.execute(node, self);
             return self;
         }
     }

src/main/java/org/truffleruby/language/objects/FreezeNode.java

@@ -9,9 +9,12 @@
  */
 package org.truffleruby.language.objects;
 
+import com.oracle.truffle.api.dsl.GenerateCached;
+import com.oracle.truffle.api.dsl.GenerateInline;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.DynamicObjectLibrary;
 import org.truffleruby.core.range.RubyObjectRange;
 import org.truffleruby.core.string.RubyString;
@@ -23,18 +26,24 @@
 
 // Specializations are order by their frequency on railsbench using --engine.SpecializationStatistics
 @GenerateUncached
+@GenerateInline
+@GenerateCached(false)
 public abstract class FreezeNode extends RubyBaseNode {
 
-    public abstract Object execute(Object object);
+    public abstract Object execute(Node node, Object object);
+
+    public static Object executeUncached(Object object) {
+        return FreezeNodeGen.getUncached().execute(null, object);
+    }
 
     @Specialization
-    protected Object freezeRubyString(RubyString object) {
+    protected static Object freezeRubyString(RubyString object) {
         return object.frozen = true;
     }
 
     @Specialization(guards = { "!isRubyObjectRange(object)", "isNotRubyString(object)" },
             limit = "getDynamicObjectCacheLimit()")
-    protected Object freeze(RubyDynamicObject object,
+    protected static Object freeze(Node node, RubyDynamicObject object,
             @CachedLibrary("object") DynamicObjectLibrary objectLibrary) {
         if (objectLibrary.isShared(object)) {
             synchronized (object) {
@@ -48,32 +57,32 @@ protected Object freeze(RubyDynamicObject object,
     }
 
     @Specialization
-    protected Object freezeRubyObjectRange(RubyObjectRange object) {
+    protected static Object freezeRubyObjectRange(RubyObjectRange object) {
         return object.frozen = true;
     }
 
     @Specialization
-    protected Object freeze(ImmutableRubyObject object) {
+    protected static Object freeze(ImmutableRubyObject object) {
         return object;
     }
 
     @Specialization
-    protected Object freeze(boolean object) {
+    protected static Object freeze(boolean object) {
         return object;
     }
 
     @Specialization
-    protected Object freeze(int object) {
+    protected static Object freeze(int object) {
         return object;
     }
 
     @Specialization
-    protected Object freeze(long object) {
+    protected static Object freeze(long object) {
         return object;
     }
 
     @Specialization
-    protected Object freeze(double object) {
+    protected static Object freeze(double object) {
         return object;
     }
 

src/main/java/org/truffleruby/language/objects/SingletonClassNode.java

@@ -133,7 +133,7 @@ protected RubyClass getSingletonClassForInstance(RubyContext context, RubyDynami
                     object);
 
             if (IsFrozenNodeGen.getUncached().execute(object)) {
-                FreezeNodeGen.getUncached().execute(singletonClass);
+                FreezeNode.executeUncached(singletonClass);
             }
 
             SharedObjects.propagate(context.getLanguageSlow(), object, singletonClass);