Testing and enhancing JavaScript Dual JVM interop (#14780)

- extracted from #14438
- this is an independent fix improving JavaScript interop
- when JavaScript strings are crossing _dual JVM_ boundary

Author: JaroslavTulach

build.sbt

@@ -4298,11 +4298,12 @@ lazy val `jvm-interop` =
       (Test / fork) := true,
       commands += WithDebugCommand.withDebug,
       libraryDependencies ++= Seq(
-        "org.graalvm.truffle" % "truffle-api"           % graalMavenPackagesVersion % "provided",
-        "org.graalvm.truffle" % "truffle-dsl-processor" % graalMavenPackagesVersion % "provided",
-        "org.graalvm.sdk"     % "graal-sdk"             % graalMavenPackagesVersion % Test,
-        "junit"               % "junit"                 % junitVersion              % Test,
-        "com.github.sbt"      % "junit-interface"       % junitIfVersion            % Test
+        "org.graalvm.truffle"  % "truffle-api"           % graalMavenPackagesVersion % "provided",
+        "org.graalvm.truffle"  % "truffle-dsl-processor" % graalMavenPackagesVersion % "provided",
+        "org.graalvm.sdk"      % "graal-sdk"             % graalMavenPackagesVersion % Test,
+        "junit"                % "junit"                 % junitVersion              % Test,
+        "com.github.sbt"       % "junit-interface"       % junitIfVersion            % Test,
+        "org.graalvm.polyglot" % "js-community"          % graalMavenPackagesVersion % Test
       ),
       Compile / moduleDependencies ++= Seq(
         "org.graalvm.truffle"  % "truffle-api" % graalMavenPackagesVersion,

lib/java/jvm-interop/src/main/java/org/enso/jvm/interop/impl/OtherInteropType.java

@@ -4,6 +4,7 @@
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.library.Message;
+import com.oracle.truffle.api.strings.TruffleString;
 import java.io.IOException;
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
@@ -600,4 +601,29 @@ protected Duration readObject(Persistance.Input in) throws IOException, ClassNot
       return Duration.ofSeconds(s, n);
     }
   }
+
+  @Persistable(id = 127)
+  static final class PersistTruffleString extends Persistance<TruffleString> {
+
+    public PersistTruffleString() {
+      super(TruffleString.class, true, 127);
+    }
+
+    @Override
+    protected void writeObject(TruffleString obj, Persistance.Output out) throws IOException {
+      var s = obj.toJavaStringUncached();
+      var bytes = s.getBytes(StandardCharsets.UTF_8);
+      out.writeInt(bytes.length);
+      out.write(bytes);
+    }
+
+    @Override
+    protected TruffleString readObject(Persistance.Input in)
+        throws IOException, ClassNotFoundException {
+      var len = in.readInt();
+      var bytes = new byte[len];
+      in.readFully(bytes);
+      return TruffleString.fromByteArrayUncached(bytes, TruffleString.Encoding.UTF_8, false);
+    }
+  }
 }

lib/java/jvm-interop/src/test/java/org/enso/jvm/interop/impl/OtherJvmJavaScriptTest.java

@@ -0,0 +1,105 @@
+package org.enso.jvm.interop.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.oracle.truffle.api.TruffleLanguage;
+import org.enso.jvm.channel.Channel;
+import org.enso.test.utils.ContextUtils;
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Value;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+public class OtherJvmJavaScriptTest {
+  @ClassRule
+  public static final ContextUtils ctx = ContextUtils.newBuilder("host").assertGC(false).build();
+
+  private static Channel<OtherJvmPool> CHANNEL;
+
+  @BeforeClass
+  public static void initializeChannel() {
+    System.setProperty("org.enso.jvm.interop.limit", "" + Integer.MAX_VALUE);
+    CHANNEL = Channel.create(null, OtherJvmPool.class);
+    CHANNEL
+        .getConfig()
+        .onEnterLeave(
+            FakeLanguage.class,
+            null,
+            (__) -> {
+              ctx.context().enter();
+              return null;
+            },
+            (__, ___) -> {
+              ctx.context().leave();
+            });
+  }
+
+  @Test
+  public void wrapTruffleString() throws Exception {
+    var testClassValue = loadOtherJvmClass(OtherJvmJavaScriptTest.class.getName());
+    assertOtherJvmObject("Represents clazz from the other JVM", testClassValue);
+
+    var result =
+        new ResultCallbacks() {
+          private Object value;
+
+          @Override
+          public void onMessage(Object o) {
+            this.value = o;
+          }
+        };
+
+    var returnedResult = testClassValue.invokeMember("multiString", "Hello", 3, result);
+    assertTrue("Represents a string", returnedResult.isString());
+
+    assertEquals("HelloHelloHello", returnedResult.asString());
+    assertEquals("HelloHelloHello", result.value.toString());
+  }
+
+  public static String multiString(String txt, int count, ResultCallbacks onResult) {
+    try (var jsCtx = Context.newBuilder("js").build()) {
+      var fn =
+          jsCtx.eval(
+              "js",
+              """
+              (function(txt, count, onResult) {
+                  let sb = "";
+                  for (let i = 0; i < count; i++) {
+                      sb = sb + txt;
+                  }
+                  onResult.onMessage(sb);
+                  return sb;
+              })
+              """);
+      var res = fn.execute(txt, count, onResult).asString();
+      return res;
+    }
+  }
+
+  private static Value loadOtherJvmClass(String name) throws Exception {
+    var msg = new OtherJvmMessage.LoadClass(name);
+    var raw = CHANNEL.execute(OtherJvmResult.class, msg).value(null);
+    if (raw instanceof OtherJvmObject other) {
+      assertTrue(other.assertChannel(CHANNEL));
+    }
+    var value = ctx.asValue(raw);
+    return value;
+  }
+
+  private static void assertOtherJvmObject(String msg, Value value) {
+    var unwrap = ctx.unwrapValue(value);
+    if (unwrap instanceof OtherJvmObject) {
+      return;
+    }
+    fail(msg + " but got: " + unwrap);
+  }
+
+  public static interface ResultCallbacks {
+    public void onMessage(Object o);
+  }
+
+  private abstract static class FakeLanguage extends TruffleLanguage<Object> {}
+}

lib/java/jvm-interop/src/test/java/org/enso/jvm/interop/impl/OtherJvmObjectTest.java

@@ -280,6 +280,8 @@ public static Object otherJvmInstances(int kind) {
       case 3 -> new int[20];
       case 4 -> "Hello";
       case 5 -> "Hello".repeat(100000);
+      case 6 -> wrap("Hello");
+      case 7 -> wrap("Hello".repeat(100000));
       default -> null;
     };
   }
@@ -350,6 +352,16 @@ public void isStringLong() throws Exception {
     checkString(5);
   }
 
+  @Test
+  public void isTruffleStringShort() throws Exception {
+    checkString(6);
+  }
+
+  @Test
+  public void isTruffleStringLong() throws Exception {
+    checkString(7);
+  }
+
   private void checkString(int kind) throws Exception {
     var localClass = ctx.asValue(OtherJvmObjectTest.class).getMember("static");
     var local1 = localClass.invokeMember("otherJvmInstances", kind);