[GR-38544] Support foreign strings fully and treat java.lang.String and TruffleString as foreign strings

PullRequest: truffleruby/3399

Author: eregon

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 New features:
 
+* Foreign strings now have all methods of Ruby `String`. They are treated as `#frozen?` UTF-8 Ruby Strings.
 
 Bug fixes:
 
@@ -15,6 +16,9 @@ Performance:
 
 Changes:
 
+* No more conversion between Java Strings and Ruby Strings at the interop boundary.
+* Removed `Truffle::Interop.{import_without_conversion,export_without_conversion}` (use `Polyglot.{import,export}` instead).
+* Removed `Truffle::Interop.members_without_conversion` (use `Truffle::Interop.members` instead).
 
 # 22.2.0
 

doc/contributor/interop.md

@@ -18,7 +18,7 @@ details.
 * [How to explicitly send messages from Ruby](#how-to-explicitly-send-messages-from-ruby)
 * [How to send messages using idiomatic Ruby](#how-to-send-messages-using-idiomatic-ruby)
 * [What messages are sent for Ruby syntax on foreign objects](#what-messages-are-sent-for-ruby-syntax-on-foreign-objects)
-* [String conversion](#string-conversion)
+* [Conversion of primitive values](#conversion-of-primitive-values)
 * [Import and export](#import-and-export)
 * [Interop eval](#interop-eval)
 * [Java interop](#java-interop)
@@ -119,39 +119,16 @@ runtime object instance.
 the foreign object, including allowing the special-forms listed above (see
 [notes on method resolution](#notes-on-method-resolution)).
 
-## String conversion
-
-Ruby strings and symbols are unboxable to Java strings.
+## Conversion of primitive values
 
 A call from Ruby to a foreign language using `NEW`, `EXECUTE`, `INVOKE`, `READ`,
-`WRITE`, or `UNBOX`, that has Ruby strings or symbols as arguments, will convert
-each Ruby string or symbol argument to a Java string. You can avoid this
+`WRITE`, or `UNBOX`, that returns a `byte`, `short` or `float` will convert the
+returned value to respectively `int`, `int` or `double`. You can avoid this
 conversion for `EXECUTE` using `Truffle::Interop.execute_without_conversion`,
 for `READ` using `Truffle::Interop.read_without_conversion`, and for `UNBOX`
 using `Truffle::Interop.unbox_without_conversion`.
 
-`Truffle::Interop.members` converts Java string member names to Ruby strings, so it
-also has a `Truffle::Interop.members_without_conversion` equivalent.
-
-A call from Ruby to a foreign language using `NEW`, `EXECUTE`, `INVOKE`, `READ`,
-`WRITE`, or `UNBOX`, that returns a Java string will convert the returned string
-to a Ruby string.
-
-A call from a foreign language to Ruby using `NEW`, `EXECUTE`, `INVOKE`, or
-`WRITE`, that has Java strings as arguments, will convert each Java string
-argument to a Ruby string.
-
-A call from a foreign language to Ruby `NEW`, `EXECUTE`, `INVOKE` or `READ`
-that returns a Ruby string will not convert it to a Java string, as this would
-break our C extension support which uses these messages to get Ruby objects
-and expects to be able to mutate them and so on
-(compare with `Truffle::Interop.execute_without_conversion`).
-
-Export and import also converts strings, and also has `_without_conversion`
-counterparts.
-
-Boxed foreign strings (foreign objects that respond positively to `IS_BOXED` and
-`UNBOX` to a Java string) unbox on `to_s`, `to_str` and `inspect`.
+`Polyglot.import` also converts `byte/short/float`.
 
 ## Import and export
 

doc/contributor/interop_implicit_api.md

@@ -31,9 +31,9 @@ Format: `Ruby code` sends `InteropLibrary message`
 - `foreign_object.method_name(*arguments, &block)` sends `invokeMember(foreign_object, method_name, *arguments, block)`
 - `foreign_object.new(*arguments)` sends `instantiate(foreign_object, *arguments)`
 - `foreign_object.inspect` returns a Ruby-style `#inspect` string showing members, array elements, etc
-- `foreign_object.to_s` sends `asString(foreign_object)` when `isString(foreign_object)` is true
+- `foreign_object.to_s` sends `asTruffleString(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` sends `asTruffleString(foreign_object)` when `isString(foreign_object)` is true
 - `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)`

doc/user/polyglot.md

@@ -20,7 +20,6 @@ The JVM configuration automatically has access to other languages.
 * [Using Ruby objects from a foreign language](#using-ruby-objects-from-a-foreign-language)
 * [Using foreign objects from Ruby](#using-foreign-objects-from-ruby)
 * [Accessing Java objects](#accessing-java-objects)
-* [Strings](#strings)
 * [Threading and interop](#threading-and-interop)
 * [Embedded configuration](#embedded-configuration)
 
@@ -223,10 +222,6 @@ boolean isNull()
 
 The [JRuby migration guide](jruby-migration.md) includes some more examples.
 
-## Strings
-
-Ruby strings and symbols are converted to Java strings when they are passed to foreign languages, and Java strings are converted to Ruby strings when they are passed into Ruby.
-
 ## Threading and Interop
 
 Ruby is designed to be a multi-threaded language and much of the ecosystem expects threads to be available.

spec/truffle/interop/boxed_spec.rb

@@ -9,17 +9,22 @@
 require_relative '../../ruby/spec_helper'
 
 describe "Truffle::Interop.boxed?" do
+  it "returns true for numbers" do
+    Truffle::Interop.boxed?(1).should be_true
+    Truffle::Interop.boxed?(1.2).should be_true
+    Truffle::Interop.boxed?(Truffle::Debug.foreign_boxed_value(2)).should be_true
+    Truffle::Interop.boxed?(Truffle::Debug.foreign_boxed_value(2.3)).should be_true
+  end
 
-  it "returns true for strings" do
-    Truffle::Interop.boxed?('test').should be_true
+  it "returns false for strings" do
+    Truffle::Interop.boxed?('test').should be_false
   end
 
-  it "returns true for symbols" do
-    Truffle::Interop.boxed?(:test).should be_true
+  it "returns false for symbols" do
+    Truffle::Interop.boxed?(:test).should be_false
   end
 
   it "returns false for other objects" do
     Truffle::Interop.boxed?(Object.new).should be_false
   end
-
 end

spec/truffle/interop/export_spec.rb

@@ -13,59 +13,49 @@
     it "exports an object" do
       object = Object.new
       Truffle::Interop.export :exports_an_object, object
-      Truffle::Interop.import(:exports_an_object).should == object
+      Truffle::Interop.import(:exports_an_object).should.equal? object
     end
 
     it "exports a primitive boolean" do
       Truffle::Interop.export :exports_a_primitive_number, true
-      Truffle::Interop.import(:exports_a_primitive_number).should be_true
+      Truffle::Interop.import(:exports_a_primitive_number).should.equal? true
     end
 
     it "exports a primitive number" do
       Truffle::Interop.export :exports_a_primitive_number, 14
-      Truffle::Interop.import(:exports_a_primitive_number).should == 14
+      Truffle::Interop.import(:exports_a_primitive_number).should.equal? 14
     end
 
     it "exports a string" do
-      Truffle::Interop.export :exports_a_string, 'hello'
-      (Truffle::Interop.import(:exports_a_string) == 'hello').should be_true
+      ruby_string = 'hello'
+      Truffle::Interop.export :exports_a_string, ruby_string
+      Truffle::Interop.import(:exports_a_string).should.equal?(ruby_string)
     end
 
-    it "exports a symbol, getting back a string" do
+    it "exports a symbol" do
       Truffle::Interop.export :exports_a_symbol, :hello
-      (Truffle::Interop.import(:exports_a_symbol) == 'hello').should be_true
+      Truffle::Interop.import(:exports_a_symbol).should.equal? :hello
     end
 
     it "exports a foreign object" do
       foreign_object = Truffle::Debug.foreign_object
       Truffle::Interop.export :exports_a_foreign_object, foreign_object
-      Truffle::Interop.import(:exports_a_foreign_object).equal?(foreign_object).should be_true
+      Truffle::Interop.import(:exports_a_foreign_object).should.equal?(foreign_object)
     end
 
     it "exports a Java string" do
-      Truffle::Interop.export :exports_a_java_string, Truffle::Interop.to_java_string('hello')
-      Truffle::Interop.import(:exports_a_java_string).should == 'hello'
+      java_string = Truffle::Interop.to_java_string('hello')
+      Truffle::Interop.export :exports_a_java_string, java_string
+      Truffle::Interop.import(:exports_a_java_string).should.equal?(java_string)
+      java_string.should == 'hello'
     end
 
-    it "converts to Java when exporting a string" do
-      Truffle::Interop.export :exports_a_string_with_conversion, 'hello'
-      imported = Truffle::Interop.import_without_conversion(:exports_a_string_with_conversion)
-      Truffle::Interop.java_string?(imported).should be_true
-      Truffle::Interop.from_java_string(imported).should == 'hello'
-    end
-
-    it "can export a string without conversion to Java" do
-      Truffle::Interop.export_without_conversion :exports_a_string_without_conversion, 'hello'
-      imported = Truffle::Interop.import_without_conversion(:exports_a_string_without_conversion)
-      Truffle::Interop.java_string?(imported).should be_false
-      imported.should == 'hello'
-    end
-
-    it "can import a string without conversion from Java" do
-      Truffle::Interop.export :imports_a_string_without_conversion, 'hello'
-      imported = Truffle::Interop.import_without_conversion(:imports_a_string_without_conversion)
-      Truffle::Interop.java_string?(imported).should be_true
-      Truffle::Interop.from_java_string(imported).should == 'hello'
+    it "does not convert to Java when exporting a Ruby string" do
+      ruby_string = 'hello'
+      Truffle::Interop.export :exports_a_string_with_conversion, ruby_string
+      imported = Truffle::Interop.import(:exports_a_string_with_conversion)
+      Truffle::Interop.should_not.java_string?(imported)
+      imported.should.equal?(ruby_string)
     end
 
     it "can be used with a string name" do
@@ -85,7 +75,7 @@
 
     it "returns the original exported value" do
       string = 'hello'
-      Truffle::Interop.export(:returns_original_value, string).equal?(string).should be_true
+      Truffle::Interop.export(:returns_original_value, string).should.equal?(string)
     end
   end
 end

spec/truffle/interop/foreign_string_spec.rb

@@ -10,14 +10,12 @@
 
 describe "Java strings" do
 
-  it "is String" do
+  it "is Interop.string?" do
     Truffle::Interop.string?(Truffle::Interop.to_java_string('test')).should be_true
   end
 
-  it "return the same object if attempted to be unboxed" do
-    unboxed = Truffle::Interop.unbox_without_conversion(Truffle::Interop.to_java_string('test'))
-    Truffle::Interop.java_string?(unboxed).should be_true
-    Truffle::Interop.from_java_string(unboxed).should == 'test'
+  it "is Interop.java_string?" do
+    Truffle::Interop.java_string?(Truffle::Interop.to_java_string('test')).should be_true
   end
 
   it "are converted to Ruby automatically on the LHS of string concatenation" do

spec/truffle/interop/java_string_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/members_spec.rb

@@ -76,11 +76,11 @@ def get_scopes()
 
     scope["c"].should == :c
     scope["c"] = :d
-    scope["c"].should == "d"
+    scope["c"].should == :d
 
     scope["a"].should == :a
     scope["a"] = :b
-    scope["a"].should == "b"
+    scope["a"].should == :b
 
     -> { scope["missing"] = "missing" }.should raise_error(NameError)
   end