[GR-44200] Support foreign big integers

PullRequest: truffleruby/3666

Author: eregon

CHANGELOG.md

@@ -4,6 +4,7 @@ New features:
 
 * Updated to Ruby 3.1.3 (#2733, @andrykonchin, @eregon).
 * `foreign_object.is_a?(foreign_meta_object)` is now supported (@eregon).
+* Foreign big integers are now supported and work with all `Numeric` operators (@eregon).
 
 Bug fixes:
 
@@ -91,6 +92,7 @@ Performance:
 Changes:
 
 * Remove `Truffle::Interop.deproxy` as it is unsafe and not useful (@eregon).
+* Removed `Truffle::Interop.unbox_without_conversion` (should not be needed by user code) (@eregon).
 
 # 22.3.0
 

doc/contributor/interop_implicit_api.md

@@ -37,8 +37,8 @@ Format: `Ruby code` sends `InteropLibrary message`
 - `foreign_object.to_str` raises `NameError` 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 `NameError`
-- `foreign_object.to_i` tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` or raises `NameError`
+- `foreign_object.to_f` tries to converts to a Ruby `Float` using `asDouble()` and `(double) asLong()` and `asBigInteger().doubleValue()` or raises `NameError`
+- `foreign_object.to_i` tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` and `asBigInteger()` or raises `NameError`
 - `foreign_object.equal?(other)` sends `isIdentical(foreign_object, other)`
 - `foreign_object.eql?(other)` sends `isIdentical(foreign_object, other)`
 - `foreign_object.object_id` sends `identityHashCode(foreign_object)` when `hasIdentity()` is true (which might not be unique)
@@ -55,7 +55,7 @@ Use `.respond_to?` for calling `InteropLibrary` predicates:
 - `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()`
-- `foreign_object.respond_to?(:to_i)` sends `fitsInLong()`
+- `foreign_object.respond_to?(:to_i)` sends `fitsInBigInteger()`
 - `foreign_object.respond_to?(:size)` sends `hasArrayElements(foreign_object)`
 - `foreign_object.respond_to?(:call)` sends `isExecutable(foreign_object)`
 - `foreign_object.respond_to?(:new)` sends `isInstantiable(foreign_object)`

spec/truffle/interop/foreign_inspect_to_s_spec.rb

@@ -88,9 +88,8 @@
     describe "Java BigInteger" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Interop.java_type("java.math.BigInteger").new('14')
-        # TODO: simplify to just ForeignNumber
-        foreign.inspect.should =~ /\A#<Polyglot::Foreign(Number|Object)\[Java\] java\.math\.BigInteger:0x\h+>\z/
-        foreign.to_s.should =~ /\A#<Polyglot::Foreign(Number|Object)\[Java\] 14>\z/
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignNumber\[Java\] java\.math\.BigInteger 14>\z/
+        foreign.to_s.should =~ /\A#<Polyglot::ForeignNumber\[Java\] 14>\z/
       end
     end
   end
@@ -112,6 +111,22 @@
     end
   end
 
+  describe "number" do
+    it "gives a similar representation to Ruby" do
+      foreign = Truffle::Debug.foreign_boxed_value(42)
+      foreign.inspect.should == "#<Polyglot::ForeignNumber 42>"
+      foreign.to_s.should == "#<Polyglot::ForeignNumber 42>"
+
+      foreign = Truffle::Debug.foreign_boxed_value(1 << 84)
+      foreign.inspect.should == "#<Polyglot::ForeignNumber[Ruby] Integer 19342813113834066795298816>"
+      foreign.to_s.should == "#<Polyglot::ForeignNumber[Ruby] 19342813113834066795298816>"
+
+      foreign = Truffle::Debug.foreign_boxed_value(3.14)
+      foreign.inspect.should == "#<Polyglot::ForeignNumber 3.14>"
+      foreign.to_s.should == "#<Polyglot::ForeignNumber 3.14>"
+    end
+  end
+
   describe "executable" do
     it "gives a similar representation to Ruby" do
       foreign = Truffle::Debug.foreign_executable(14)

spec/truffle/interop/polyglot/class_spec.rb

@@ -21,6 +21,7 @@
     Truffle::Debug.foreign_iterator.class.should == Polyglot::ForeignIterator
     Truffle::Debug.java_null.class.should == Polyglot::ForeignNull
     Truffle::Debug.foreign_boxed_value(42).class.should == Polyglot::ForeignNumber
+    Truffle::Debug.foreign_boxed_value(1 << 84).class.should == Polyglot::ForeignNumber
     Truffle::Debug.foreign_boxed_value(3.14).class.should == Polyglot::ForeignNumber
     Truffle::Debug.foreign_pointer(0x1234).class.should == Polyglot::ForeignPointer
     Truffle::Debug.foreign_string("foo").class.should == Polyglot::ForeignString
@@ -39,6 +40,7 @@
     Truffle::Interop.proxy_foreign_object((1..3).each).class.should == Polyglot::ForeignIterableIterator
     Truffle::Interop.proxy_foreign_object(nil).class.should == Polyglot::ForeignNull
     Truffle::Interop.proxy_foreign_object(42).class.should == Polyglot::ForeignNumber
+    Truffle::Interop.proxy_foreign_object(1 << 84).class.should == Polyglot::ForeignNumber
     Truffle::Interop.proxy_foreign_object(3.14).class.should == Polyglot::ForeignNumber
     Truffle::Interop.proxy_foreign_object(Truffle::FFI::Pointer::NULL).class.should == Polyglot::ForeignPointer
     Truffle::Interop.proxy_foreign_object("foo").class.should == Polyglot::ForeignString
@@ -59,7 +61,7 @@
       Java.type('java.util.ArrayDeque').new.class.should == Polyglot::ForeignIterable
       Truffle::Interop.to_java_list([1, 2, 3]).iterator.class.should == Polyglot::ForeignIterator
       Truffle::Debug.java_null.class.should == Polyglot::ForeignNull
-      # ForeignNumber
+      Java.type('java.math.BigInteger').valueOf(42).class.should == Polyglot::ForeignNumber
       # ForeignPointer
       Java.type('java.lang.String').new("foo").class.should == Polyglot::ForeignString
       Truffle::Interop.to_java_string("foo").class.should == Polyglot::ForeignString

spec/truffle/interop/polyglot/foreign_number_spec.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2022, 2023 Oracle and/or its affiliates. All rights reserved. This
+# code is released under a tri EPL/GPL/LGPL license. You can use it,
+# redistribute it and/or modify it under the terms of the:
+#
+# Eclipse Public License version 2.0, or
+# GNU General Public License version 2, or
+# GNU Lesser General Public License version 2.1.
+
+require_relative '../../../ruby/spec_helper'
+
+describe "Polyglot::ForeignNumber" do
+  before :each do
+    @numbers = [
+      [Truffle::Debug.foreign_boxed_value(42), 42],
+      [Truffle::Debug.foreign_boxed_value(1 << 84), 1 << 84],
+      [Truffle::Debug.foreign_boxed_value(3.14), 3.14],
+    ]
+  end
+
+  it "supports #==" do
+    @numbers.each do |foreign, ruby|
+      foreign.should == ruby
+      foreign.should == foreign
+      ruby.should == foreign
+    end
+  end
+
+  it "supports #+@" do
+    @numbers.each do |foreign, ruby|
+      (+foreign).should == (+ruby)
+    end
+  end
+
+  it "supports #-@" do
+    @numbers.each do |foreign, ruby|
+      (-foreign).should == (-ruby)
+    end
+  end
+
+  it "supports #+" do
+    @numbers.each do |foreign, ruby|
+      (foreign + 3).should == (ruby + 3)
+      (3 + foreign).should == (3 + ruby)
+    end
+  end
+
+  it "supports #-" do
+    @numbers.each do |foreign, ruby|
+      (foreign - 3).should == (ruby - 3)
+      (3 - foreign).should == (3 - ruby)
+    end
+  end
+
+  it "supports #*" do
+    @numbers.each do |foreign, ruby|
+      (foreign * 3).should == (ruby * 3)
+      (3 * foreign).should == (3 * ruby)
+    end
+  end
+
+  it "supports #/" do
+    @numbers.each do |foreign, ruby|
+      (foreign / 3).should == (ruby / 3)
+      (3 / foreign).should == (3 / ruby)
+    end
+  end
+
+  it "supports #**" do
+    @numbers.each do |foreign, ruby|
+      (foreign ** 2).should == (ruby ** 2)
+    end
+  end
+
+  it "does not support odd? yet" do
+    @numbers.each do |foreign, _ruby|
+      -> { foreign.odd? }.should raise_error(Polyglot::UnsupportedMessageError)
+    end
+  end
+end

spec/truffle/interop/special_forms_spec.rb

@@ -270,7 +270,7 @@
     -> { pfo.to_a }.should raise_error(NameError)
   end
 
-  it doc['.to_f', 'tries to converts to a Ruby `Float` using `asDouble()` and `(double) asLong()` or raises `NameError`'] do
+  it doc['.to_f', 'tries to converts to a Ruby `Float` using `asDouble()` and `(double) asLong()` and `asBigInteger().doubleValue()` or raises `NameError`'] do
     pfo, _, l = proxy[42]
     pfo.to_f.should.eql?(42.0)
     l.log.should include(["fitsInDouble"])
@@ -282,12 +282,18 @@
     l.log.should include(["fitsInDouble"])
     l.log.should include(["asLong"])
 
+    does_not_fit_perfectly_in_double = (1 << 84) + 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(["asBigInteger"])
+
     pfo, _, l = proxy[Object.new]
     -> { pfo.to_f }.should raise_error(NameError, /to_f/)
     l.log.should include(["isNumber"])
   end
 
-  it doc['.to_i', 'tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` or raises `NameError`'] do
+  it doc['.to_i', 'tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` and `asBigInteger()` or raises `NameError`'] do
     pfo, _, l = proxy[42]
     pfo.to_i.should.eql?(42)
     l.log.should include(["fitsInInt"])
@@ -298,6 +304,11 @@
     l.log.should include(["fitsInLong"])
     l.log.should include(["asLong"])
 
+    pfo, _, l = proxy[1 << 84]
+    pfo.to_i.should.eql?(1 << 84)
+    l.log.should include(["fitsInBigInteger"])
+    l.log.should include(["asBigInteger"])
+
     pfo, _, l = proxy[Object.new]
     -> { pfo.to_i }.should raise_error(NameError, /to_i/)
     l.log.should include(["isNumber"])
@@ -403,10 +414,10 @@
     l.log.should include(["fitsInDouble"])
   end
 
-  it doc['.respond_to?(:to_i)', 'sends `fitsInLong()`'] do
+  it doc['.respond_to?(:to_i)', 'sends `fitsInBigInteger()`'] do
     pfo, _, l = proxy[42]
     pfo.should.respond_to?(:to_i)
-    l.log.should include(["fitsInLong"])
+    l.log.should include(["fitsInBigInteger"])
   end
 
   it description['.respond_to?(:size)', :hasArrayElements] do

src/main/java/org/truffleruby/core/numeric/RubyBignum.java

@@ -11,13 +11,15 @@
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 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.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
 import org.truffleruby.RubyContext;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.language.ImmutableRubyObjectNotCopyable;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 
 @ExportLibrary(InteropLibrary.class)
@@ -34,6 +36,11 @@ public RubyBignum(BigInteger value) {
         this.value = value;
     }
 
+    @TruffleBoundary
+    private int bitLength() {
+        return value.bitLength();
+    }
+
     @TruffleBoundary
     @Override
     public String toString() {
@@ -58,4 +65,129 @@ public RubyClass getMetaObject(
         return RubyContext.get(node).getCoreLibrary().integerClass;
     }
     // endregion
+
+    // region Number messages
+    @ExportMessage
+    boolean isNumber() {
+        return true;
+    }
+
+    @ExportMessage
+    boolean fitsInByte() {
+        return bitLength() < Byte.SIZE;
+    }
+
+    @ExportMessage
+    boolean fitsInShort() {
+        return bitLength() < Short.SIZE;
+    }
+
+    @ExportMessage
+    boolean fitsInInt() {
+        return bitLength() < Integer.SIZE;
+    }
+
+    @ExportMessage
+    boolean fitsInLong() {
+        return bitLength() < Long.SIZE;
+    }
+
+    @ExportMessage
+    boolean fitsInBigInteger() {
+        return true;
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    boolean fitsInFloat() {
+        if (bitLength() <= 24) { // 24 = size of float mantissa + 1
+            return true;
+        } else {
+            float floatValue = value.floatValue();
+            if (!Float.isFinite(floatValue)) {
+                return false;
+            }
+            return new BigDecimal(floatValue).toBigIntegerExact().equals(value);
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    boolean fitsInDouble() {
+        if (bitLength() <= 53) { // 53 = size of double mantissa + 1
+            return true;
+        } else {
+            double doubleValue = value.doubleValue();
+            if (!Double.isFinite(doubleValue)) {
+                return false;
+            }
+            return new BigDecimal(doubleValue).toBigIntegerExact().equals(value);
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    byte asByte() throws UnsupportedMessageException {
+        try {
+            return value.byteValueExact();
+        } catch (ArithmeticException e) {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    short asShort() throws UnsupportedMessageException {
+        try {
+            return value.shortValueExact();
+        } catch (ArithmeticException e) {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    int asInt() throws UnsupportedMessageException {
+        try {
+            return value.intValueExact();
+        } catch (ArithmeticException e) {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    long asLong() throws UnsupportedMessageException {
+        try {
+            return value.longValueExact();
+        } catch (ArithmeticException e) {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    float asFloat() throws UnsupportedMessageException {
+        if (fitsInFloat()) {
+            return value.floatValue();
+        } else {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @TruffleBoundary
+    @ExportMessage
+    double asDouble() throws UnsupportedMessageException {
+        if (fitsInDouble()) {
+            return value.doubleValue();
+        } else {
+            throw UnsupportedMessageException.create();
+        }
+    }
+
+    @ExportMessage
+    BigInteger asBigInteger() {
+        return value;
+    }
+    // endregion
 }