Integrate foreign objects better with Ruby objects

* By giving foreign objects a proper Ruby class.
* Move the logic for all special methods on foreign objects (Implicit polyglot API)
  to regular Ruby methods of Polyglot::ForeignObject and Polyglot trait modules.
* Automatically generate Polyglot::Foreign* classes composing the InteropLibrary traits.
* #[] on foreign arrays now return nil if out of bounds like Array#[].
* Foreign arrays now have all methods of Enumerable and many methods of Array.
* Simplify Polyglot::ForeignObject#respond_to? now that most are defined as Ruby methods.
* Fixes oracle#2149
* From oracle#2153

Co-authored-by: Benoit Daloze <benoit.daloze@oracle.com>

CHANGELOG.md

@@ -5,6 +5,8 @@ New features:
 * [TRegex](https://github.com/oracle/graal/tree/master/regex) is now used by default, which provides large speedups for matching regular expressions.
 * Add `Polyglot.languages` to expose the list of available languages.
 * Add `Polyglot::InnerContext` to eval code in any available language in an inner isolated context (#2169).
+* Foreign objects now have a dynamically-generated class based on their interop traits like `ForeignArray` and are better integrated with Ruby objects (#2149).
+* Foreign arrays now have all methods of Ruby `Enumerable` and many methods of `Array` (#2149).
 
 Bug fixes:
 

doc/contributor/interop_implicit_api.md

@@ -32,11 +32,11 @@ Format: `Ruby code` sends `InteropLibrary message`
 - `foreign_object.to_s` sends `asString(foreign_object)` when `isString(foreign_object)` is true
 - `foreign_object.to_s` sends `toDisplayString(foreign_object)` otherwise
 - `foreign_object.to_str` sends `asString(foreign_object)` when `isString(foreign_object)` is true
-- `foreign_object.to_str` raises `NoMethodError` otherwise
+- `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 `TypeError`
-- `foreign_object.to_i` tries to converts to a Ruby `Integer` using `asInt()` and `asLong()` or raises `TypeError`
+- `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.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)
@@ -52,8 +52,8 @@ Use `.respond_to?` for calling `InteropLibrary` predicates:
 - `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?(:to_f)` sends `fitsInDouble()`
+- `foreign_object.respond_to?(:to_i)` sends `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/foreign_inspect_to_s_spec.rb

@@ -13,24 +13,24 @@
     describe "Java null" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Debug.java_null
-        foreign.inspect.should == "#<Java null>"
-        foreign.to_s.should == "#<Java null>"
+        foreign.inspect.should == "#<Polyglot::ForeignNull[Java] null>"
+        foreign.to_s.should == "#<Polyglot::ForeignNull[Java] null>"
       end
     end
 
     describe "Java list" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Interop.to_java_list([1, 2, 3])
-        foreign.inspect.should =~ /\A#<Java java\.util\.Arrays\$ArrayList:0x\h+ \[1, 2, 3\]>\z/
-        foreign.to_s.should == "#<Java [1, 2, 3]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignArray\[Java\] java\.util\.Arrays\$ArrayList:0x\h+ \[1, 2, 3\]>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignArray[Java] [1, 2, 3]>"
       end
     end
 
     describe "Java array" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Interop.to_java_array([1, 2, 3])
-        foreign.inspect.should =~ /\A#<Java int\[\]:0x\h+ \[1, 2, 3\]>\z/
-        foreign.to_s.should == "#<Java [1, 2, 3]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignArray\[Java\] int\[\]:0x\h+ \[1, 2, 3\]>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignArray[Java] [1, 2, 3]>"
       end
     end
 
@@ -40,24 +40,24 @@
         foreign = Truffle::Interop.to_java_map(hash)
 
         hash.to_s.should == '{:a=>1, :b=>2, :c=>3}' # for comparison
-        foreign.inspect.should =~ /\A#<Java java\.util\.HashMap:0x\h+ {"a"=>1, "b"=>2, "c"=>3}>\z/
-        foreign.to_s.should == "#<Java {a=1, b=2, c=3}>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignObject\[Java\] java\.util\.HashMap:0x\h+ {"a"=>1, "b"=>2, "c"=>3}>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignObject[Java] {a=1, b=2, c=3}>"
       end
     end
 
     describe "Java class" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Interop.java_type("java.math.BigInteger")
-        foreign.inspect.should == "#<Java class java.math.BigInteger>"
-        foreign.to_s.should == "#<Java java.math.BigInteger>"
+        foreign.inspect.should == "#<Polyglot::ForeignInstantiable[Java] class java.math.BigInteger>"
+        foreign.to_s.should == "#<Polyglot::ForeignInstantiable[Java] java.math.BigInteger>"
       end
     end
 
     describe "Java object" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Interop.java_type("java.math.BigInteger").new('14')
-        foreign.inspect.should =~ /\A#<Java java\.math\.BigInteger:0x\h+ .+>\z/
-        foreign.to_s.should == "#<Java 14>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignObject\[Java\] java\.math\.BigInteger:0x\h+ .+>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignObject[Java] 14>"
       end
     end
   end
@@ -67,47 +67,47 @@
       x = [1, 2, 3]
       foreign = Truffle::Debug.foreign_array_from_java(Truffle::Interop.to_java_array(x))
       foreign[0] = foreign
-      foreign.inspect.should =~ /\A#<Foreign:0x\h+ \[\[...\], 2, 3\]>\z/
-      foreign.to_s.should == "#<Foreign [foreign array]>"
+      foreign.inspect.should =~ /\A#<Polyglot::ForeignArray:0x\h+ \[\[...\], 2, 3\]>\z/
+      foreign.to_s.should == "#<Polyglot::ForeignArray [foreign array]>"
     end
   end
 
   describe "null" do
     it "gives a similar representation to Ruby" do
       foreign = Truffle::Debug.foreign_null
-      foreign.inspect.should == "#<Foreign null>"
-      foreign.to_s.should == "#<Foreign [foreign null]>"
+      foreign.inspect.should == "#<Polyglot::ForeignNull null>"
+      foreign.to_s.should == "#<Polyglot::ForeignNull [foreign null]>"
     end
   end
 
   describe "executable" do
     it "gives a similar representation to Ruby" do
       foreign = Truffle::Debug.foreign_executable(14)
-      foreign.inspect.should =~ /\A#<Foreign:0x\h+ proc>\z/
-      foreign.to_s.should == "#<Foreign [foreign executable]>"
+      foreign.inspect.should =~ /\A#<Polyglot::ForeignExecutable:0x\h+ proc>\z/
+      foreign.to_s.should == "#<Polyglot::ForeignExecutable [foreign executable]>"
     end
   end
 
   describe "pointer" do
     it "gives a similar representation to Ruby" do
       foreign = Truffle::Debug.foreign_pointer(0x1234)
-      foreign.inspect.should == "#<Foreign pointer 0x1234>"
-      foreign.to_s.should == "#<Foreign [foreign pointer]>"
+      foreign.inspect.should == "#<Polyglot::ForeignPointer 0x1234>"
+      foreign.to_s.should == "#<Polyglot::ForeignPointer [foreign pointer]>"
     end
   end
 
   guard -> { !TruffleRuby.native? } do
     describe "array" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Debug.foreign_array_from_java(Truffle::Interop.to_java_array([1, 2, 3]))
-        foreign.inspect.should =~ /\A#<Foreign:0x\h+ \[1, 2, 3\]>\z/
-        foreign.to_s.should == "#<Foreign [foreign array]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignArray:0x\h+ \[1, 2, 3\]>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignArray [foreign array]>"
       end
 
       it "gives a similar representation to Ruby, even if it is also a pointer" do
         foreign = Truffle::Debug.foreign_pointer_array_from_java(Truffle::Interop.to_java_array([1, 2, 3]))
-        foreign.inspect.should =~ /\A#<Foreign pointer 0x\h+ \[1, 2, 3\]>\z/
-        foreign.to_s.should == "#<Foreign [foreign pointer array]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignArrayPointer 0x0 \[1, 2, 3\]>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignArrayPointer [foreign pointer array]>"
       end
     end
   end
@@ -116,16 +116,16 @@
     describe "object without members" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Debug.foreign_object
-        foreign.inspect.should =~ /\A#<Foreign:0x\h+>\z/
-        foreign.to_s.should == "#<Foreign [foreign object]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignObject:0x\h+>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignObject [foreign object]>"
       end
     end
 
     describe "object with members" do
       it "gives a similar representation to Ruby" do
         foreign = Truffle::Debug.foreign_object_from_map(Truffle::Interop.to_java_map({a: 1, b: 2, c: 3}))
-        foreign.inspect.should =~ /\A#<Foreign:0x\h+ a=1, b=2, c=3>\z/
-        foreign.to_s.should == "#<Foreign [foreign object with members]>"
+        foreign.inspect.should =~ /\A#<Polyglot::ForeignObject:0x\h+ a=1, b=2, c=3>\z/
+        foreign.to_s.should == "#<Polyglot::ForeignObject [foreign object with members]>"
       end
     end
   end

spec/truffle/interop/polyglot/foreign_array_spec.rb

@@ -0,0 +1,141 @@
+# Copyright (c) 2017, 2020 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::ForeignArray" do
+  before :each do
+    @foreign = Truffle::Interop.to_java_array([1, 2, 3])
+    @empty = Truffle::Interop.to_java_array([])
+  end
+
+  it "should have class ForeignArray" do
+    @foreign.inspect.should =~ /\A#<Polyglot::ForeignArray\[Java\] int\[\]:0x\h+ \[1, 2, 3\]>/
+    @foreign.length.should == 3
+  end
+
+  it "should index array with #[]" do
+    @foreign[0].should == 1
+    @foreign[1].should == 2
+    @foreign[2].should == 3
+    @foreign[-1].should == 3
+    @foreign[-3].should == 1
+    @foreign[3].should == nil
+    @foreign[-4].should == nil
+  end
+
+  it "should index array with #at" do
+    @foreign.at(0).should == 1
+    @foreign.at(1).should == 2
+    @foreign.at(2).should == 3
+    @foreign.at(-1).should == 3
+    @foreign.at(-3).should == 1
+    @foreign.at(3).should == nil
+    @foreign.at(-4).should == nil
+  end
+
+  it "should access the first element with #first" do
+    @foreign.first.should == 1
+    @empty.first.should == nil
+  end
+
+  it "should access the last element with #last" do
+    @foreign.last.should == 3
+    @empty.last.should == nil
+  end
+
+  it "supports #each" do
+    index = 0
+    @foreign.each do |val|
+      val.should == (index += 1)
+    end
+  end
+
+  it "supports #each_with_index" do
+    @foreign.each_with_index do |val, index|
+      val.should == (index + 1)
+    end
+  end
+
+  it "returns an Enumerator for #each with no block" do
+    enum = @foreign.each
+    enum.class.should == Enumerator
+    enum.each_with_index do |val, index|
+      @foreign[index].should == val
+    end
+  end
+
+  it "supports #take" do
+    slice = @foreign.take(2)
+    slice[0].should == 1
+    slice[1].should == 2
+    slice.at(2).should == nil
+  end
+
+  it "should allow assignment of array element with #[]=" do
+    @foreign[2] = 10
+    @foreign[2].should == 10
+  end
+
+  it "should allow the use of #next" do
+    enum = @foreign.each
+    enum.class.should == Enumerator
+    enum.next.should == 1
+  end
+
+  it "supports #count" do
+    foreign = Truffle::Interop.to_java_array([1, 2, 4, 2])
+    foreign.count.should == 4
+    foreign.count(2).should == 2
+    foreign.count { |x| x % 2 == 0 }.should == 3
+  end
+end
+
+describe "Foreign arrays" do
+  it "can be printed with #print" do
+    foreign = Truffle::Interop.to_java_array([1, 2, 3])
+    -> {
+      print foreign
+    }.should output_to_fd(foreign.to_s)
+  end
+
+  it "can be printed with #puts" do
+    -> {
+      puts Truffle::Interop.to_java_array([1, 2, 3])
+    }.should output_to_fd("1\n2\n3\n")
+  end
+
+  it "can be printed with #p" do
+    foreign = Truffle::Interop.to_java_array([1, 2, 3])
+    -> {
+      p foreign
+    }.should output_to_fd("#{foreign.inspect}\n")
+  end
+end
+
+describe "Foreign arrays that are also pointers" do
+  it "can be printed with #print" do
+    foreign = Truffle::Debug.foreign_pointer_array_from_java(Truffle::Interop.to_java_array([1, 2, 3]))
+    -> {
+      print foreign
+    }.should output_to_fd(foreign.to_s)
+  end
+
+  it "can be printed with #puts" do
+    -> {
+      puts Truffle::Debug.foreign_pointer_array_from_java(Truffle::Interop.to_java_array([1, 2, 3]))
+    }.should output_to_fd("1\n2\n3\n")
+  end
+
+  it "can be printed with #p" do
+    foreign = Truffle::Debug.foreign_pointer_array_from_java(Truffle::Interop.to_java_array([1, 2, 3]))
+    -> {
+      p foreign
+    }.should output_to_fd("#{foreign.inspect}\n")
+  end
+end

spec/truffle/interop/polyglot/inner_context_spec.rb

@@ -27,8 +27,8 @@
     Polyglot::InnerContext.new do |context|
       obj = context.eval('ruby', "Object.new")
       Truffle::Interop.should.foreign?(obj)
-      obj.to_s.should.start_with?("#<Ruby #<Object:")
-      obj.inspect.should.start_with?("#<Ruby Object:")
+      obj.to_s.should.start_with?("#<Polyglot::ForeignObject[Ruby] #<Object:")
+      obj.inspect.should.start_with?("#<Polyglot::ForeignObject[Ruby] Object:")
     end
   end