Implement foreign.to_f and foreign.to_i

* Fixes #2038

Author: eregon

CHANGELOG.md

@@ -14,6 +14,7 @@ New features:
 * The Java stacktrace is now shown when sending SIGQUIT to the process, also on TruffleRuby Native, see [Debugging](doc/user/debugging.md) for details (#2041).
 * Calls to foreign objects with a block argument will now pass the block as the last argument.
 * `foreign.name` will now use `invokeMember` if invocable and if not use `readMember`, see `doc/contrib/interop_implicit_api.md` for details.
+* `foreign.to_f` and `foreign.to_i` will now attempt to convert to Ruby `Float` and `Integer` (#2038).
 
 Bug fixes:
 

doc/contributor/interop_implicit_api.md

@@ -35,13 +35,17 @@ Format: `Ruby code` sends `InteropLibrary message`
 - `foreign_object.to_str` raises `NoMethodError` otherwise
 - `foreign_object.to_a` converts to a Ruby `Array` with `Truffle::Interop.to_array(foreign_object)`
 - `foreign_object.to_ary` converts to a Ruby `Array` with `Truffle::Interop.to_array(foreign_object)`
+- `foreign_object.to_f` tries to converts to a Ruby `Float` using `asDouble()` and `(double) asLong()` or raises `TypeError`
+- `foreign_object.to_i` tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` or raises `TypeError`
 
 Use `.respond_to?` for calling `InteropLibrary` predicates:
 - `foreign_object.respond_to?(:inspect)` is always true
 - `foreign_object.respond_to?(:to_s)` is always true
 - `foreign_object.respond_to?(:to_str)` sends `isString(foreign_object)`
 - `foreign_object.respond_to?(:to_a)` sends `hasArrayElements(foreign_object)`
 - `foreign_object.respond_to?(:to_ary)` sends `hasArrayElements(foreign_object)`
+- `foreign_object.respond_to?(:to_f)` sends `fitsInDouble()` and `fitsInLong()`
+- `foreign_object.respond_to?(:to_i)` sends `fitsInInt()` and `fitsInLong()`
 - `foreign_object.respond_to?(:size)` sends `hasArrayElements(foreign_object)`
 - `foreign_object.respond_to?(:keys)` sends `hasMembers(foreign_object)`
 - `foreign_object.respond_to?(:call)` sends `isExecutable(foreign_object)`

spec/truffle/interop/special_forms_spec.rb

@@ -244,6 +244,42 @@
     l.log.should include(["hasArrayElements"])
   end
 
+  it doc['.to_f', 'tries to converts to a Ruby `Float` using `asDouble()` and `(double) asLong()` or raises `TypeError`'] do
+    pfo, _, l = proxy[42]
+    pfo.to_f.should.eql?(42.0)
+    l.log.should include(["fitsInDouble"])
+    l.log.should include(["asDouble"])
+
+    does_not_fit_perfectly_in_double = (1 << 62) + 1
+    pfo, _, l = proxy[does_not_fit_perfectly_in_double]
+    pfo.to_f.should.eql?(does_not_fit_perfectly_in_double.to_f)
+    l.log.should include(["fitsInDouble"])
+    l.log.should include(["fitsInLong"])
+    l.log.should include(["asLong"])
+
+    pfo, _, l = proxy[Object.new]
+    -> { pfo.to_f }.should raise_error(TypeError, "can't convert foreign object to Float")
+    l.log.should include(["fitsInDouble"])
+    l.log.should include(["fitsInLong"])
+  end
+
+  it doc['.to_i', 'tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` or raises `TypeError`'] do
+    pfo, _, l = proxy[42]
+    pfo.to_i.should.eql?(42)
+    l.log.should include(["fitsInInt"])
+    l.log.should include(["asInt"])
+
+    pfo, _, l = proxy[1 << 42]
+    pfo.to_i.should.eql?(1 << 42)
+    l.log.should include(["fitsInLong"])
+    l.log.should include(["asLong"])
+
+    pfo, _, l = proxy[Object.new]
+    -> { pfo.to_i }.should raise_error(TypeError, "can't convert foreign object to Integer")
+    l.log.should include(["fitsInInt"])
+    l.log.should include(["fitsInLong"])
+  end
+
   output << "\nUse `.respond_to?` for calling `InteropLibrary` predicates:\n"
 
   it doc['.respond_to?(:inspect)', "is always true"] do
@@ -272,6 +308,20 @@
     l.log.should include(["hasArrayElements"])
   end
 
+  it doc['.respond_to?(:to_f)', 'sends `fitsInDouble()` and `fitsInLong()`'] do
+    pfo, _, l = proxy[Object.new]
+    pfo.respond_to?(:to_f)
+    l.log.should include(["fitsInDouble"])
+    l.log.should include(["fitsInLong"])
+  end
+
+  it doc['.respond_to?(:to_i)', 'sends `fitsInInt()` and `fitsInLong()`'] do
+    pfo, _, l = proxy[Object.new]
+    pfo.respond_to?(:to_i)
+    l.log.should include(["fitsInInt"])
+    l.log.should include(["fitsInLong"])
+  end
+
   it description['.respond_to?(:size)', :hasArrayElements] do
     pfo, _, l = proxy[Object.new]
     pfo.respond_to?(:size)

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

@@ -26,7 +26,9 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.interop.InteropException;
 import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
 @GenerateUncached
@@ -46,6 +48,8 @@ public abstract class OutgoingForeignCallNode extends RubyBaseNode {
     protected final static String NEW = "new";
     protected final static String TO_A = "to_a";
     protected final static String TO_ARY = "to_ary";
+    protected final static String TO_I = "to_i";
+    protected final static String TO_F = "to_f";
     protected final static String RESPOND_TO = "respond_to?";
     protected final static String SEND = "__send__";
     protected final static String NIL = "nil?";
@@ -206,6 +210,52 @@ protected Object deleteMember(Object receiver, String name, Object[] args,
         return dispatchNode.call(context.getCoreLibrary().truffleInteropModule, "remove_member", receiver, args[0]);
     }
 
+    @Specialization(guards = { "name == cachedName", "cachedName.equals(TO_F)", "args.length == 0" }, limit = "1")
+    protected double toF(Object receiver, String name, Object[] args,
+            @Cached(value = "name", allowUncached = true) @Shared("name") String cachedName,
+            @CachedLibrary("receiver") InteropLibrary interop,
+            @Cached TranslateInteropExceptionNode translateInteropException,
+            @CachedContext(RubyLanguage.class) RubyContext context,
+            @Cached BranchProfile errorProfile) {
+        try {
+            if (interop.fitsInDouble(receiver)) {
+                return interop.asDouble(receiver);
+            } else if (interop.fitsInLong(receiver)) {
+                return (double) interop.asLong(receiver);
+            } else {
+                errorProfile.enter();
+                throw new RaiseException(
+                        context,
+                        context.getCoreExceptions().typeError("can't convert foreign object to Float", this));
+            }
+        } catch (UnsupportedMessageException e) {
+            throw translateInteropException.execute(e);
+        }
+    }
+
+    @Specialization(guards = { "name == cachedName", "cachedName.equals(TO_I)", "args.length == 0" }, limit = "1")
+    protected Object toI(Object receiver, String name, Object[] args,
+            @Cached(value = "name", allowUncached = true) @Shared("name") String cachedName,
+            @CachedLibrary("receiver") InteropLibrary interop,
+            @Cached TranslateInteropExceptionNode translateInteropException,
+            @CachedContext(RubyLanguage.class) RubyContext context,
+            @Cached BranchProfile errorProfile) {
+        try {
+            if (interop.fitsInInt(receiver)) {
+                return interop.asInt(receiver);
+            } else if (interop.fitsInLong(receiver)) {
+                return interop.asLong(receiver);
+            } else {
+                errorProfile.enter();
+                throw new RaiseException(
+                        context,
+                        context.getCoreExceptions().typeError("can't convert foreign object to Integer", this));
+            }
+        } catch (UnsupportedMessageException e) {
+            throw translateInteropException.execute(e);
+        }
+    }
+
     protected static boolean canHaveBadArguments(String cachedName) {
         return cachedName.equals(INDEX_READ) || cachedName.equals(INDEX_WRITE) || cachedName.equals(SEND) ||
                 cachedName.equals(NIL) || cachedName.equals(EQUAL) || cachedName.equals(OBJECT_ID) ||
@@ -240,6 +290,8 @@ protected static int expectedArity(String name) {
             case KEYS:
             case INSPECT:
             case CLASS:
+            case TO_F:
+            case TO_I:
             case TO_S:
             case TO_STR:
             case NIL:

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

@@ -359,6 +359,10 @@ def self.foreign_respond_to?(object, name)
       case name.to_sym
       when :to_a, :to_ary
         Truffle::Interop.has_array_elements?(object)
+      when :to_f
+        Truffle::Interop.fits_in_double?(object) || Truffle::Interop.fits_in_long?(object)
+      when :to_i
+        Truffle::Interop.fits_in_int?(object) || Truffle::Interop.fits_in_long?(object)
       when :new
         Truffle::Interop.instantiable?(object)
       when :size