Move ForeignObject#{equal?,eql?} to BasicObject's ReferenceEqualNode node

* So it is also correct if the nodes are used directly,
  and better integrated with Ruby objects.
* It also means #== is properly defined on foreign objects now.

Author: eregon

spec/truffle/interop/fixtures/classes.rb

@@ -11,14 +11,17 @@
 module TruffleInteropSpecs
 
   class Logger
-    attr_reader :log
-
     def initialize
       @log = []
     end
 
     def <<(*args)
-      @log << args
+      @log << args unless @log.frozen?
+    end
+
+    def log
+      # Stop recording so messages caused by spec expectations are not included
+      @log.freeze
     end
   end
 

spec/truffle/interop/special_forms_spec.rb

@@ -287,6 +287,7 @@
     pfo.equal?(pfo).should == true
     l.log.should include(["isIdentical", pfo, :InteropLibrary])
 
+    pfo, _, l = proxy[Object.new]
     other = Object.new
     pfo.equal?(other).should == false
     l.log.should include(["isIdentical", other, :InteropLibrary])
@@ -297,6 +298,7 @@
     pfo.eql?(pfo).should == true
     l.log.should include(["isIdentical", pfo, :InteropLibrary])
 
+    pfo, _, l = proxy[Object.new]
     other = Object.new
     pfo.eql?(other).should == false
     l.log.should include(["isIdentical", other, :InteropLibrary])
@@ -312,7 +314,7 @@
   it doc['.object_id', 'uses `System.identityHashCode()` otherwise (which might not be unique)'] do
     pfo, _, l = proxy[42] # primitives have no identity in InteropLibrary
     pfo.object_id.should be_kind_of(Integer)
-    l.log.should include(["isIdentical", pfo, :InteropLibrary]) # hasIdentity()
+    l.log.should include(["isIdenticalOrUndefined", 42]) # hasIdentity()
     l.log.should_not include(["identityHashCode"])
   end
 
@@ -326,7 +328,7 @@
   it doc['.__id__', 'uses `System.identityHashCode()` otherwise (which might not be unique)'] do
     pfo, _, l = proxy[42] # primitives have no identity in InteropLibrary
     pfo.__id__.should be_kind_of(Integer)
-    l.log.should include(["isIdentical", pfo, :InteropLibrary]) # hasIdentity()
+    l.log.should include(["isIdenticalOrUndefined", 42]) # hasIdentity()
     l.log.should_not include(["identityHashCode"])
   end
 
@@ -340,7 +342,7 @@
   it doc['.hash', 'uses `System.identityHashCode()` otherwise (which might not be unique)'] do
     pfo, _, l = proxy[42] # primitives have no identity in InteropLibrary
     pfo.hash.should be_kind_of(Integer)
-    l.log.should include(["isIdentical", pfo, :InteropLibrary]) # hasIdentity()
+    l.log.should include(["isIdenticalOrUndefined", 42]) # hasIdentity()
     l.log.should_not include(["identityHashCode"])
   end
 

src/main/.checkstyle_checks.xml

@@ -212,7 +212,7 @@
     </module>
     <module name="RegexpSinglelineJava">
       <property name="format" value='"isRuby(?!Value|DynamicObject|SymbolOrString|Rational|[^"]+\|\|)'/> <!-- Rational is not a builtin type -->
-      <property name="message" value="Type the argument instead of using a positive is Ruby* guard."/>
+      <property name="message" value="Type the argument instead of using a positive isRuby* guard."/>
     </module>
     <module name="RegexpSinglelineJava">
       <property name="format" value='"isNil'/>

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

@@ -10,7 +10,6 @@
 package org.truffleruby.core.basicobject;
 
 import com.oracle.truffle.api.RootCallTarget;
-import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.object.Shape;
@@ -152,16 +151,42 @@ protected boolean equal(double a, double b) {
             return Double.doubleToRawLongBits(a) == Double.doubleToRawLongBits(b);
         }
 
-        @Specialization(guards = { "a.getClass() == b.getClass()", "!isPrimitive(a)" }) // since a and b have the same class, implies !isPrimitive(b)
-        protected boolean equalSameClassNonPrimitive(Object a, Object b) {
+        @Specialization(guards = { "isNonPrimitiveRubyObject(a)", "isNonPrimitiveRubyObject(b)" })
+        protected boolean equalRubyObjects(Object a, Object b) {
             return a == b;
         }
 
-        @Fallback
-        protected boolean fallback(Object a, Object b) {
+        @Specialization(guards = { "isNonPrimitiveRubyObject(a)", "isPrimitive(b)" })
+        protected boolean rubyObjectPrimitive(Object a, Object b) {
             return false;
         }
 
+        @Specialization(guards = { "isPrimitive(a)", "isNonPrimitiveRubyObject(b)" })
+        protected boolean primitiveRubyObject(Object a, Object b) {
+            return false;
+        }
+
+        @Specialization(guards = { "isPrimitive(a)", "isPrimitive(b)", "!comparablePrimitives(a, b)" })
+        protected boolean nonComparablePrimitives(Object a, Object b) {
+            return false;
+        }
+
+        @Specialization(guards = "isForeignObject(a) || isForeignObject(b)", limit = "getInteropCacheLimit()")
+        protected boolean equalForeign(Object a, Object b,
+                @CachedLibrary("a") InteropLibrary lhsInterop,
+                @CachedLibrary("b") InteropLibrary rhsInterop) {
+            return lhsInterop.isIdentical(a, b, rhsInterop);
+        }
+
+        protected static boolean isNonPrimitiveRubyObject(Object object) {
+            return object instanceof RubyDynamicObject || object instanceof ImmutableRubyObject;
+        }
+
+        protected static boolean comparablePrimitives(Object a, Object b) {
+            return (a instanceof Boolean && b instanceof Boolean) ||
+                    (RubyGuards.isImplicitLong(a) && RubyGuards.isImplicitLong(b)) ||
+                    (RubyGuards.isImplicitDouble(a) && RubyGuards.isImplicitDouble(b));
+        }
     }
 
     @GenerateUncached

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

@@ -231,11 +231,6 @@ def class
       end
     end
 
-    def equal?(other_object)
-      Truffle::Interop.identical?(self, other_object)
-    end
-    alias_method :eql?, :equal?
-
     def inspect
       recursive_string_for(self) if Truffle::ThreadOperations.detect_recursion self do
         return Truffle::InteropOperations.foreign_inspect_nonrecursive(self)