Builtins expose Enso methods

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/DebuggingEnsoTest.java

@@ -42,23 +42,23 @@
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.Value;
 import org.graalvm.polyglot.io.IOAccess;
-import org.junit.After;
+import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TestWatcher;
 import org.junit.runner.Description;
 
 public class DebuggingEnsoTest {
-  private Context context;
-  private Engine engine;
-  private Debugger debugger;
-  private final ByteArrayOutputStream out = new ByteArrayOutputStream();
+  private static Context context;
+  private static Engine engine;
+  private static Debugger debugger;
+  private static final ByteArrayOutputStream out = new ByteArrayOutputStream();
 
-  @Before
-  public void initContext() {
-    out.reset();
+  @BeforeClass
+  public static void initContext() {
     engine =
         Engine.newBuilder()
             .allowExperimentalOptions(true)
@@ -85,12 +85,18 @@ public void initContext() {
     Assert.assertNotNull("Enso found: " + langs, langs.get("enso"));
   }
 
-  @After
-  public void disposeContext() throws IOException {
+  @AfterClass
+  public static void disposeContext() throws IOException {
     context.close();
     context = null;
     engine.close();
     engine = null;
+    debugger = null;
+  }
+
+  @Before
+  public void resetOut() {
+    out.reset();
   }
 
   /** Only print warnings from the compiler if a test fails. */
@@ -307,10 +313,10 @@ public void hostValueIsTreatedAsItsEnsoCounterpart() {
 
         foo _ =
             d_enso = Date.new 2024 12 15
-            d_js = js_date
             d_java = Date.parse "2024-12-15"
             dt_enso = Date_Time.now
             dt_java = Date_Time.parse "2020-05-06 04:30:20" "yyyy-MM-dd HH:mm:ss"
+            dt_js = js_date
             str_enso = "Hello_World"
             str_js = js_str
             str_java = String.new "Hello_World"
@@ -335,13 +341,13 @@ public void hostValueIsTreatedAsItsEnsoCounterpart() {
 
                   DebugValue ensoDate = scope.getDeclaredValue("d_enso");
                   DebugValue javaDate = scope.getDeclaredValue("d_java");
-                  DebugValue jsDate = scope.getDeclaredValue("d_js");
                   assertSameProperties(ensoDate.getProperties(), javaDate.getProperties());
-                  assertSameProperties(ensoDate.getProperties(), jsDate.getProperties());
 
                   DebugValue ensoDateTime = scope.getDeclaredValue("dt_enso");
                   DebugValue javaDateTime = scope.getDeclaredValue("dt_java");
+                  DebugValue jsDateTime = scope.getDeclaredValue("dt_js");
                   assertSameProperties(ensoDateTime.getProperties(), javaDateTime.getProperties());
+                  assertSameProperties(ensoDateTime.getProperties(), jsDateTime.getProperties());
 
                   DebugValue ensoString = scope.getDeclaredValue("str_enso");
                   DebugValue javaString = scope.getDeclaredValue("str_java");

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/VectorSortTest.java

@@ -61,18 +61,23 @@ public static void disposeCtx() {
 
   @Theory
   public void testSortHandlesAllValues(Value value1, Value value2) {
-    Assume.assumeFalse(isNan(value1) || isNan(value2));
-    Value res = sortFunc.execute(value1, value2);
-    assertTrue(res.hasArrayElements());
-    assertEquals(2, res.getArraySize());
-    List<Value> resArray = readPolyglotArray(res);
-    // check that value1 is there unchanged on some index, and the same for value2
-    assertTrue(
-        "Sorted vector should contain the first value at any index",
-        invokeEquals(value1, resArray.get(0)) || invokeEquals(value1, resArray.get(1)));
-    assertTrue(
-        "Sorted vector should contain the second value at any index",
-        invokeEquals(value2, resArray.get(0)) || invokeEquals(value2, resArray.get(1)));
+    ContextUtils.executeInContext(
+        context,
+        () -> {
+          Assume.assumeFalse(isNan(value1) || isNan(value2));
+          Value res = sortFunc.execute(value1, value2);
+          assertTrue(res.hasArrayElements());
+          assertEquals(2, res.getArraySize());
+          List<Value> resArray = readPolyglotArray(res);
+          // check that value1 is there unchanged on some index, and the same for value2
+          assertTrue(
+              "Sorted vector should contain the first value at any index",
+              invokeEquals(value1, resArray.get(0)) || invokeEquals(value1, resArray.get(1)));
+          assertTrue(
+              "Sorted vector should contain the second value at any index",
+              invokeEquals(value2, resArray.get(0)) || invokeEquals(value2, resArray.get(1)));
+          return null;
+        });
   }
 
   private boolean isNan(Value value) {

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/builtins/BuiltinsExposeMethodsTest.java

@@ -0,0 +1,147 @@
+package org.enso.interpreter.test.builtins;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+
+import com.oracle.truffle.api.interop.InteropLibrary;
+import java.util.ArrayList;
+import java.util.List;
+import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.library.dispatch.TypeOfNode;
+import org.enso.interpreter.test.ValuesGenerator;
+import org.enso.interpreter.test.ValuesGenerator.Language;
+import org.enso.test.utils.ContextUtils;
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.Value;
+import org.junit.AfterClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Gathers all the builtin objects from {@link ValuesGenerator}. From their types, gathers all their
+ * methods via their {@link org.enso.interpreter.runtime.scope.ModuleScope definition scope} and
+ * checks that {@link Value#canInvokeMember(String)} returns true.
+ */
+@RunWith(Parameterized.class)
+public class BuiltinsExposeMethodsTest {
+  private static Context ctx;
+
+  private final ValueWithType valueWithType;
+
+  public BuiltinsExposeMethodsTest(ValueWithType valueWithType) {
+    this.valueWithType = valueWithType;
+  }
+
+  private static Context ctx() {
+    if (ctx == null) {
+      ctx = ContextUtils.createDefaultContext();
+    }
+    return ctx;
+  }
+
+  @Parameters(name = "{index}: {0}")
+  public static Iterable<ValueWithType> generateBuiltinObjects() {
+    var valuesGenerator = ValuesGenerator.create(ctx(), Language.ENSO);
+    var builtinObjectsWithTypes = new ArrayList<ValueWithType>();
+    ContextUtils.executeInContext(
+        ctx(),
+        () -> {
+          valuesGenerator.allValues().stream()
+              .map(val -> new ValueWithType(val, getType(val)))
+              .filter(valWithType -> !shouldSkipType(valWithType.type))
+              .filter(valWithType -> !isPrimitive(valWithType.value))
+              .filter(valWithType -> !isHostValue(valWithType.value))
+              .forEach(builtinObjectsWithTypes::add);
+          return null;
+        });
+    return builtinObjectsWithTypes;
+  }
+
+  private static Type getType(Value object) {
+    var unwrapped = ContextUtils.unwrapValue(ctx(), object);
+    return TypeOfNode.getUncached().findTypeOrNull(unwrapped);
+  }
+
+  @AfterClass
+  public static void disposeCtx() {
+    if (ctx != null) {
+      ctx.close();
+      ctx = null;
+    }
+  }
+
+  @Test
+  public void builtinExposeMethods() {
+    ContextUtils.executeInContext(
+        ctx(),
+        () -> {
+          assertThat(valueWithType, is(notNullValue()));
+          assertThat(valueWithType.type.isBuiltin(), is(true));
+          var typeDefScope = valueWithType.type.getDefinitionScope();
+          var methodsDefinedInScope = typeDefScope.getMethodsForType(valueWithType.type);
+          if (methodsDefinedInScope != null) {
+            for (var methodInScope : methodsDefinedInScope) {
+              var methodName = methodInScope.getName();
+              if (methodName.contains(".")) {
+                var items = methodName.split("\\.");
+                methodName = items[items.length - 1];
+              }
+              assertThat(
+                  "Builtin type " + valueWithType.type.getQualifiedName() + " should have members",
+                  valueWithType.value.hasMembers(),
+                  is(true));
+              assertThat(
+                  "Member " + methodName + " should be present",
+                  valueWithType.value.hasMember(methodName),
+                  is(true));
+              assertThat(
+                  "Member " + methodName + " should be invocable",
+                  valueWithType.value.canInvokeMember(methodName),
+                  is(true));
+              var interop = InteropLibrary.getUncached();
+              var unwrappedValue = ContextUtils.unwrapValue(ctx(), valueWithType.value);
+              var memberViaInterop = interop.readMember(unwrappedValue, methodName);
+              assertThat(
+                  "Member via interop should be the same as in scope, but was: " + memberViaInterop,
+                  memberViaInterop == methodInScope,
+                  is(true));
+            }
+          }
+          return null;
+        });
+  }
+
+  private static boolean isPrimitive(Value object) {
+    var unwrapped = ContextUtils.unwrapValue(ctx(), object);
+    return unwrapped instanceof Long
+        || unwrapped instanceof Boolean
+        || unwrapped instanceof Integer
+        || unwrapped instanceof Double;
+  }
+
+  private static boolean shouldSkipType(Type type) {
+    if (type == null) {
+      return true;
+    }
+    if (!type.isBuiltin()) {
+      return true;
+    }
+    var builtins = ContextUtils.leakContext(ctx()).getBuiltins();
+    var typesToSkip =
+        List.of(
+            builtins.function(), builtins.dataflowError(), builtins.warning(), builtins.nothing());
+    var shouldBeSkipped = typesToSkip.stream().anyMatch(toSkip -> toSkip == type);
+    return shouldBeSkipped;
+  }
+
+  private static boolean isHostValue(Value value) {
+    var unwrapped = ContextUtils.unwrapValue(ctx(), value);
+    var ensoCtx = ContextUtils.leakContext(ctx());
+    return ensoCtx.isJavaPolyglotObject(unwrapped);
+  }
+
+  public record ValueWithType(Value value, Type type) {}
+}

engine/runtime-integration-tests/src/test/java/org/enso/interpreter/test/builtins/InvokeBuiltinMethodViaInteropTest.java

@@ -0,0 +1,120 @@
+package org.enso.interpreter.test.builtins;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import com.oracle.truffle.api.interop.InteropLibrary;
+import org.enso.test.utils.ContextUtils;
+import org.graalvm.polyglot.Context;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * This test tries to invoke some builtin methods on builtin types via the {@link
+ * com.oracle.truffle.api.interop.InteropLibrary interop} protocol.
+ */
+public class InvokeBuiltinMethodViaInteropTest {
+  private static Context ctx;
+
+  @BeforeClass
+  public static void setUp() {
+    ctx = ContextUtils.createDefaultContext();
+  }
+
+  @AfterClass
+  public static void tearDown() {
+    ctx.close();
+    ctx = null;
+  }
+
+  @Test
+  public void invokeGetMethodOnRef() {
+    var code =
+        """
+        import Standard.Base.Runtime.Ref.Ref
+
+        main = Ref.new 42
+        """;
+    var ref = ContextUtils.evalModule(ctx, code);
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var interop = InteropLibrary.getUncached();
+          var refUnwrapped = ContextUtils.unwrapValue(ctx, ref);
+          assertThat(
+              "Ref should have a 'get' method",
+              interop.isMemberInvocable(refUnwrapped, "get"),
+              is(true));
+          var res = interop.invokeMember(refUnwrapped, "get");
+          assertThat("Ref.get should return a number", interop.isNumber(res), is(true));
+          assertThat("Ref.get should return 42", interop.asInt(res), is(42));
+          return null;
+        });
+  }
+
+  /**
+   * 'Text.reverse' is an extension method defined outside builtins module scope, so it cannot be
+   * resolved.
+   */
+  @Test
+  public void extensionMethodOnBuiltinTypeIsNotResolved() {
+    var text = ContextUtils.evalModule(ctx, "main = 'Hello'");
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var interop = InteropLibrary.getUncached();
+          var textUnwrapped = ContextUtils.unwrapValue(ctx, text);
+          assertThat(
+              "Text should not be able to resolve 'reverse' method",
+              interop.isMemberInvocable(textUnwrapped, "reverse"),
+              is(false));
+          return null;
+        });
+  }
+
+  @Test
+  public void invokePlusOnTextWithParameter() {
+    var text1 = ContextUtils.evalModule(ctx, "main = 'First'");
+    var text2 = ContextUtils.evalModule(ctx, "main = 'Second'");
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var interop = InteropLibrary.getUncached();
+          var text1Unwrapped = ContextUtils.unwrapValue(ctx, text1);
+          var text2Unwrapped = ContextUtils.unwrapValue(ctx, text2);
+          assertThat(
+              "Text should have a '+' method",
+              interop.isMemberInvocable(text1Unwrapped, "+"),
+              is(true));
+          var res = interop.invokeMember(text1Unwrapped, "+", text2Unwrapped);
+          assertThat("Text.+ should return a text", interop.isString(res), is(true));
+          assertThat(
+              "Text.+ should return 'FirstSecond'", interop.asString(res), is("FirstSecond"));
+          return null;
+        });
+  }
+
+  /**
+   * 'Text.is_empty' is not a builtin method, defined on a builtin type. It should be treated as a
+   * builtin method, thus be invocable via interop.
+   */
+  @Test
+  public void invokeNonBuiltinMethodOnBuiltinType() {
+    var text = ContextUtils.evalModule(ctx, "main = 'Hello'");
+    ContextUtils.executeInContext(
+        ctx,
+        () -> {
+          var interop = InteropLibrary.getUncached();
+          var textUnwrapped = ContextUtils.unwrapValue(ctx, text);
+          assertThat(
+              "Text should have a 'is_empty' method",
+              interop.isMemberInvocable(textUnwrapped, "is_empty"),
+              is(true));
+          var res = interop.invokeMember(textUnwrapped, "is_empty");
+          assertThat("Text.is_empty should return a boolean", interop.isBoolean(res), is(true));
+          assertThat("Text.is_empty should return false", interop.asBoolean(res), is(false));
+          return null;
+        });
+  }
+}

engine/runtime-integration-tests/src/test/scala/org/enso/interpreter/test/semantic/DateTest.scala

@@ -73,7 +73,7 @@ class DateTest extends InterpreterTest {
            |""".stripMargin
       val ensoDate = eval(code)
       consumeOut shouldEqual List("2022", "4", "1", "2022-04-01")
-      ensoDate.getMemberKeys().size() shouldEqual 0
+      ensoDate.getMemberKeys().size() shouldNot be(0)
     }
   }
 }