Do not convert the elements to Ruby Strings for Truffle::Interop.members

* Let them be as foreign strings.

Author: eregon

doc/contributor/interop.md

@@ -130,10 +130,6 @@ using `Truffle::Interop.unbox_without_conversion`.
 
 Import also converts `byte/short/float`, and has a `import_without_conversion` counterpart.
 
-`Truffle::Interop.members` converts Java string member names to Ruby strings, so it
-also has a `Truffle::Interop.members_without_conversion` equivalent.
-TODO remove?
-
 ## Import and export
 
 `Truffle::Interop.export(:name, value)`

spec/truffle/interop/members_spec.rb

@@ -16,15 +16,19 @@
     keys.should be_an_instance_of(Array)
   end
 
-  it "returns an array of Ruby strings by default" do
-    keys = Truffle::Interop.members({'a' => 1, 'b' => 2, 'c' => 3})
-    keys[0].should be_an_instance_of(String)
-  end
+  it "returns an array of interop strings" do
+    keys = Truffle::Interop.members(Object.new)
+    keys.each do |key|
+      Truffle::Interop.should.string? key
+      String.should === key # actually Ruby Strings
+    end
 
-  it "returns an array of Java strings if you don't use conversion" do
-    keys = Truffle::Interop.members_without_conversion({'a' => 1, 'b' => 2, 'c' => 3})
-    key = keys[0]
-    Truffle::Interop.java_string?(key).should be_true
+    members = Truffle::Interop.members(Truffle::Debug.foreign_object_with_members)
+    members.should == ["a", "b", "c", "method1", "method2"]
+    members.each do |key|
+      Truffle::Interop.should.string? key
+      Truffle::Interop.should.java_string? key # actually Java Strings
+    end
   end
 
   it "returns an array of public methods for an array" do

spec/truffle/interop/polyglot/foreign_array_spec.rb

@@ -14,6 +14,17 @@
     @empty = Truffle::Interop.to_java_array([])
   end
 
+  it "compares #== if elements are #==" do
+    foreign = Truffle::Interop.to_java_array([
+      Truffle::Debug.foreign_string("one"),
+      Truffle::Interop.as_string("two"),
+      Truffle::Interop.as_truffle_string("three")])
+    ruby = ["one", "two", "three"]
+
+    foreign.should == ruby
+    ruby.should == foreign
+  end
+
   it "supports #length and #size" do
     @foreign.size.should == 3
     @foreign.length.should == 3

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

@@ -1230,7 +1230,7 @@ protected boolean hasMembers(Object receiver,
         }
     }
 
-    @CoreMethod(names = "members_without_conversion", onSingleton = true, required = 1, optional = 1)
+    @CoreMethod(names = "members", onSingleton = true, required = 1, optional = 1)
     public abstract static class GetMembersNode extends PrimitiveArrayArgumentsNode {
 
         protected abstract Object executeMembers(Object receiver, boolean internal);

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

@@ -97,10 +97,6 @@ def self.import(name)
       Primitive.foreign_to_ruby(import_without_conversion(name))
     end
 
-    def self.members(object, internal = false)
-      members_without_conversion(object, internal).map { |key| from_java_string(key) }
-    end
-
     def self.get_members_implementation(object, internal)
       keys = []
 
@@ -125,7 +121,7 @@ def self.get_members_implementation(object, internal)
         end
       end
 
-      keys.map { |s| Truffle::Interop.to_java_string(s) }
+      keys
     end
     private_class_method :get_members_implementation
 

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

@@ -246,6 +246,14 @@ def to_ary
     end
     alias_method :to_a, :to_ary
 
+    def ==(other)
+      to_ary == other
+    end
+
+    def index(...)
+      to_a.index(...)
+    end
+
     def reverse
       to_a.reverse
     end
@@ -483,19 +491,19 @@ def instance_variable_set(member, value)
 
     def instance_variables
       return [] unless Truffle::Interop.has_members?(self)
-      Truffle::Interop.members_without_conversion(self).filter_map do |member|
+      Truffle::Interop.members(self).filter_map do |member|
         # Ruby does not have the concept of non-readable members, ignore those
         if Truffle::Interop.member_readable?(self, member) &&
             !Truffle::Interop.member_invocable?(self, member)
-          member.to_s.to_sym
+          member.to_sym
         end
       end
     end
 
     def methods(regular = true)
       if regular
-        super() | Truffle::Interop.members_without_conversion(self).filter_map do |member|
-          member.to_s.to_sym if Truffle::Interop.member_invocable?(self, member)
+        super() | Truffle::Interop.members(self).filter_map do |member|
+          member.to_sym if Truffle::Interop.member_invocable?(self, member)
         end
       else
         super(regular)