No longer convert java.lang.String eagerly at the interop boundary

* Instead just treat them like any other foreign string.

Author: eregon

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,20 @@ 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`.
 
+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.
-
-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`.
+TODO remove?
 
 ## 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,65 @@
     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'
+    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_without_conversion(:exports_a_string_with_conversion)
-      Truffle::Interop.java_string?(imported).should be_true
-      Truffle::Interop.from_java_string(imported).should == 'hello'
+      Truffle::Interop.should_not.java_string?(imported)
+      imported.should.equal?(ruby_string)
     end
 
     it "can export a string without conversion to Java" do
-      Truffle::Interop.export_without_conversion :exports_a_string_without_conversion, 'hello'
+      ruby_string = 'hello'
+      Truffle::Interop.export_without_conversion :exports_a_string_without_conversion, ruby_string
       imported = Truffle::Interop.import_without_conversion(:exports_a_string_without_conversion)
-      Truffle::Interop.java_string?(imported).should be_false
-      imported.should == 'hello'
+      Truffle::Interop.should_not.java_string?(imported)
+      imported.should.equal?(ruby_string)
     end
 
     it "can import a string without conversion from Java" do
-      Truffle::Interop.export :imports_a_string_without_conversion, 'hello'
+      ruby_string = 'hello'
+      Truffle::Interop.export :imports_a_string_without_conversion, ruby_string
       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'
+      Truffle::Interop.should_not.java_string?(imported)
+      imported.should.equal?(ruby_string)
     end
 
     it "can be used with a string name" do
@@ -85,7 +91,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

@@ -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

spec/truffle/interop/node_library_spec.rb

@@ -52,16 +52,19 @@
       Truffle::Interop.to_java_array([1, 2, 3]).class.should == Polyglot::ForeignArray
       Truffle::Interop.to_java_list([1, 2, 3]).class.should == Polyglot::ForeignArray
       Java.type('java.lang.RuntimeException').new.class.should == Polyglot::ForeignException
-      # ForeignExecutable
+      Java.type('java.lang.Thread').currentThread.class.should == Polyglot::ForeignExecutable # Thread implements Runnable
       Java.type('java.math.BigInteger').class.should == Polyglot::ForeignClass
       Java.type('java.math.BigInteger')[:class].class.should == Polyglot::ForeignClass
       Java.type('int').class.should == Polyglot::ForeignMetaObject
-      # ForeignIterable
+      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
       # ForeignPointer
-      Java.type('java.lang.String').new("foo").class.should == String # Should be Polyglot::ForeignString
+      Java.type('java.lang.String').new("foo").class.should == Polyglot::ForeignString
+      Truffle::Interop.to_java_string("foo").class.should == Polyglot::ForeignString
+      Truffle::Interop.as_string("foo").class.should == Polyglot::ForeignString
+      Truffle::Interop.as_truffle_string("foo").class.should == Polyglot::ForeignString
     end
   end
 end