refactor hashing & reference comparison nodes to accomodate @GenerateUnached

Author: Nicolas Laurent

src/main/java/org/truffleruby/core/basicobject/BasicObjectNodes.java

@@ -117,13 +117,20 @@ protected boolean equal(VirtualFrame frame, Object a, Object b) {
     /** This node is not trivial because primitives must be compared by value and never by identity. Also, this node
      * must consider (byte) n and (short) n and (int) n and (long) n equal, as well as (float) n and (double) n. So even
      * if a and b have different classes they might still be equal if they are primitives. */
+    @GenerateUncached
+    @GenerateNodeFactory
     @CoreMethod(names = { "equal?", "==" }, required = 1)
-    public abstract static class ReferenceEqualNode extends CoreMethodArrayArgumentsNode {
+    @NodeChild(value = "arguments", type = RubyNode[].class)
+    public abstract static class ReferenceEqualNode extends RubySourceNode {
 
         public static ReferenceEqualNode create() {
             return ReferenceEqualNodeFactory.create(null);
         }
 
+        public static ReferenceEqualNode getUncached() {
+            return ReferenceEqualNodeFactory.getUncached();
+        }
+
         public abstract boolean executeReferenceEqual(Object a, Object b);
 
         @Specialization

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

@@ -9,25 +9,23 @@
  */
 package org.truffleruby.core.cast;
 
+import com.oracle.truffle.api.dsl.CachedContext;
+import com.oracle.truffle.api.dsl.GenerateUncached;
+import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.numeric.RubyBignum;
-import org.truffleruby.language.RubyContextSourceNode;
-import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.dispatch.DispatchNode;
 
 import com.oracle.truffle.api.dsl.Cached;
-import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 
 /** See {@link ToIntNode} for a comparison of different integer conversion nodes. */
-@NodeChild(value = "child", type = RubyNode.class)
-public abstract class ToRubyIntegerNode extends RubyContextSourceNode {
+@GenerateUncached
+public abstract class ToRubyIntegerNode extends RubyBaseNode {
 
     public static ToRubyIntegerNode create() {
-        return ToRubyIntegerNodeGen.create(null);
-    }
-
-    public static ToRubyIntegerNode create(RubyNode child) {
-        return ToRubyIntegerNodeGen.create(child);
+        return ToRubyIntegerNodeGen.create();
     }
 
     public abstract Object execute(Object object);
@@ -49,7 +47,8 @@ protected RubyBignum coerceRubyBignum(RubyBignum value) {
 
     @Specialization(guards = "!isRubyInteger(object)")
     protected Object coerceObject(Object object,
+            @CachedContext(RubyLanguage.class) RubyContext context,
             @Cached DispatchNode toIntNode) {
-        return toIntNode.call(getContext().getCoreLibrary().truffleTypeModule, "rb_to_int_fallback", object);
+        return toIntNode.call(context.getCoreLibrary().truffleTypeModule, "rb_to_int_fallback", object);
     }
 }

src/main/java/org/truffleruby/core/hash/HashingNodes.java

@@ -13,18 +13,22 @@
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.CachedContext;
 import com.oracle.truffle.api.dsl.Fallback;
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.Specialization;
 import org.truffleruby.RubyContext;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.basicobject.BasicObjectNodes.ObjectIDNode;
 import org.truffleruby.core.cast.ToRubyIntegerNode;
+import org.truffleruby.core.hash.HashingNodesFactory.HashCastResultNodeGen;
+import org.truffleruby.core.hash.HashingNodesFactory.ToHashByIdentityNodeGen;
 import org.truffleruby.core.numeric.BigIntegerOps;
 import org.truffleruby.core.numeric.RubyBignum;
 import org.truffleruby.core.string.RubyString;
 import org.truffleruby.core.string.StringNodes;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.core.symbol.SymbolNodes;
 import org.truffleruby.core.string.ImmutableRubyString;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyContextNode;
 import org.truffleruby.language.dispatch.DispatchNode;
 
@@ -137,7 +141,16 @@ private int castResult(Object value) {
 
     }
 
-    public abstract static class ToHashByIdentity extends RubyContextNode {
+    @GenerateUncached
+    public abstract static class ToHashByIdentity extends RubyBaseNode {
+
+        public static ToHashByIdentity create() {
+            return ToHashByIdentityNodeGen.create();
+        }
+
+        public static ToHashByIdentity getUncached() {
+            return ToHashByIdentityNodeGen.getUncached();
+        }
 
         public abstract int execute(Object key);
 
@@ -147,19 +160,15 @@ protected int toHashByIdentity(Object hashed,
                 @Cached HashCastResultNode hashCastResultNode) {
             return hashCastResultNode.execute(objectIDNode.execute(hashed));
         }
-
     }
 
-
-    public abstract static class HashCastResultNode extends RubyContextNode {
-
-        @Child private ToRubyIntegerNode toRubyInteger;
-        @Child private HashCastResultNode hashCastResultNode;
+    @GenerateUncached
+    public abstract static class HashCastResultNode extends RubyBaseNode {
 
         public abstract int execute(Object key);
 
         public static HashCastResultNode create() {
-            return HashingNodesFactory.HashCastResultNodeGen.create();
+            return HashCastResultNodeGen.create();
         }
 
         @Specialization
@@ -177,24 +186,11 @@ protected int castBignum(RubyBignum hashed) {
             return BigIntegerOps.hashCode(hashed);
         }
 
-        @Fallback
-        protected int castOther(Object hashed) {
-            if (toRubyInteger == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                toRubyInteger = insert(ToRubyIntegerNode.create());
-            }
-            final Object coercedHashedObject = toRubyInteger.execute(hashed);
-            return castCoerced(coercedHashedObject);
+        @Specialization(guards = "!isRubyInteger(hashed)")
+        protected int castOther(Object hashed,
+                @Cached ToRubyIntegerNode toRubyInteger,
+                @Cached HashCastResultNode hashCastResult) {
+            return hashCastResult.execute(toRubyInteger.execute(hashed));
         }
-
-        private int castCoerced(Object coerced) {
-            if (hashCastResultNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                hashCastResultNode = insert(HashCastResultNode.create());
-            }
-            return hashCastResultNode.execute(coerced);
-        }
-
     }
-
 }

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

@@ -9,12 +9,7 @@
 # GNU Lesser General Public License version 2.1.
 
 module ObjectSpace
-  # WeakMap uses identity comparison semantics. The implementation assumes that the Java representation of objects
-  # do compare (equals() and hashCode()) using object identity. This is the case for instances of RubyDynamicObject,
-  # boxed primitives, and RubySymbol.
-  #
-  # However, results are unspecified if used with instances of TruffleObject that override equals() and
-  # hashCode().
+  # WeakMap uses Ruby identity semantics to compare and hash keys.
   class WeakMap
     include Enumerable