Rename Primitive.object_can_contain_object to Primitive.array_can_contain_object?

Author: eregon

src/main/java/org/truffleruby/core/array/ArrayNodes.java

@@ -2380,14 +2380,14 @@ private Entry(RubyArray array, int index) {
         @Specialization(guards = "!canContainObject.execute(array)", limit = "1")
         protected boolean flattenHelperPrimitive(RubyArray array, RubyArray out, int maxLevels,
                 @Cached @Exclusive ArrayAppendManyNode concat,
-                @Cached @Exclusive TypeNodes.CanContainObjectNode canContainObject) {
+                @Cached @Exclusive ArrayCanContainObjectNode canContainObject) {
             concat.executeAppendMany(out, array);
             return false;
         }
 
         @Specialization(replaces = "flattenHelperPrimitive")
         protected boolean flattenHelper(RubyArray array, RubyArray out, int maxLevels,
-                @Cached @Exclusive TypeNodes.CanContainObjectNode canContainObject,
+                @Cached @Exclusive ArrayCanContainObjectNode canContainObject,
                 @Cached @Exclusive ArrayAppendManyNode concat,
                 @Cached AtNode at,
                 @Cached DispatchNode convert,
@@ -2457,4 +2457,40 @@ private static void add(EconomicSet<RubyArray> set, RubyArray array) {
             set.add(array);
         }
     }
+
+    @Primitive(name = "array_can_contain_object?")
+    @ImportStatic(ArrayGuards.class)
+    public abstract static class ArrayCanContainObjectNode extends PrimitiveArrayArgumentsNode {
+
+        @NeverDefault
+        public static ArrayCanContainObjectNode create() {
+            return ArrayNodesFactory.ArrayCanContainObjectNodeFactory.create(null);
+        }
+
+        public abstract boolean execute(RubyArray array);
+
+        @Specialization(
+                guards = {
+                        "stores.accepts(array.getStore())",
+                        "stores.isPrimitive(array.getStore())" })
+        protected boolean primitiveArray(RubyArray array,
+                @CachedLibrary(limit = "storageStrategyLimit()") ArrayStoreLibrary stores) {
+            return false;
+        }
+
+        @Specialization(
+                guards = {
+                        "stores.accepts(array.getStore())",
+                        "!stores.isPrimitive(array.getStore())" })
+        protected boolean objectArray(RubyArray array,
+                @CachedLibrary(limit = "storageStrategyLimit()") ArrayStoreLibrary stores) {
+            return true;
+        }
+
+        @Specialization(guards = "!isRubyArray(array)")
+        protected boolean other(Object array) {
+            return true;
+        }
+
+    }
 }

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

@@ -20,9 +20,7 @@
 import org.truffleruby.annotations.CoreModule;
 import org.truffleruby.annotations.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
-import org.truffleruby.core.array.ArrayGuards;
 import org.truffleruby.core.array.RubyArray;
-import org.truffleruby.core.array.library.ArrayStoreLibrary;
 import org.truffleruby.core.basicobject.BasicObjectNodes.ReferenceEqualNode;
 import org.truffleruby.core.cast.BooleanCastNode;
 import org.truffleruby.core.cast.ToIntNode;
@@ -54,7 +52,6 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
-import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.library.CachedLibrary;
@@ -359,42 +356,6 @@ protected Object objectHiddenVarSet(RubyDynamicObject object, Object identifier,
         }
     }
 
-    @Primitive(name = "object_can_contain_object")
-    @ImportStatic(ArrayGuards.class)
-    public abstract static class CanContainObjectNode extends PrimitiveArrayArgumentsNode {
-
-        @NeverDefault
-        public static CanContainObjectNode create() {
-            return TypeNodesFactory.CanContainObjectNodeFactory.create(null);
-        }
-
-        public abstract boolean execute(RubyArray array);
-
-        @Specialization(
-                guards = {
-                        "stores.accepts(array.getStore())",
-                        "stores.isPrimitive(array.getStore())" })
-        protected boolean primitiveArray(RubyArray array,
-                @CachedLibrary(limit = "storageStrategyLimit()") ArrayStoreLibrary stores) {
-            return false;
-        }
-
-        @Specialization(
-                guards = {
-                        "stores.accepts(array.getStore())",
-                        "!stores.isPrimitive(array.getStore())" })
-        protected boolean objectArray(RubyArray array,
-                @CachedLibrary(limit = "storageStrategyLimit()") ArrayStoreLibrary stores) {
-            return true;
-        }
-
-        @Specialization(guards = "!isRubyArray(array)")
-        protected boolean other(Object array) {
-            return true;
-        }
-
-    }
-
     @Primitive(name = "rb_any_to_s")
     public abstract static class ObjectToSNode extends PrimitiveArrayArgumentsNode {
         @Specialization

src/main/ruby/truffleruby/core/array.rb

@@ -518,7 +518,7 @@ def flatten!(level = -1)
   end
 
   def hash
-    unless Primitive.object_can_contain_object(self)
+    unless Primitive.array_can_contain_object?(self)
       # Primitive arrays do not need the recursion check
       return hash_internal
     end

src/main/ruby/truffleruby/core/truffle/thread_operations.rb

@@ -67,7 +67,7 @@ module Truffle::ThreadOperations
   # If there is one, it returns true.
   # Otherwise, it will yield once and return false.
   def self.detect_recursion(obj, &block)
-    unless Primitive.object_can_contain_object obj
+    unless Primitive.array_can_contain_object? obj
       yield
       return false
     end
@@ -81,7 +81,7 @@ def self.detect_recursion(obj, &block)
   # If there is one, it returns true.
   # Otherwise, it will yield once and return false.
   def self.detect_pair_recursion(obj, paired_obj)
-    unless Primitive.object_can_contain_object obj
+    unless Primitive.array_can_contain_object? obj
       yield
       return false
     end