Builtins expose Enso methods

engine/runtime-integration-tests/src/test/java/org/enso/example/PolyglotTestClass.java

@@ -0,0 +1,18 @@
+package org.enso.example;
+
+import java.time.LocalDate;
+import org.graalvm.polyglot.Value;
+
+public class PolyglotTestClass {
+  public static boolean isPolyglotDate_Object(Object obj) {
+    return obj instanceof Value polyglotVal && polyglotVal.isDate();
+  }
+
+  public static boolean isPolyglotDate_LocalDate(LocalDate date) {
+    return date != null;
+  }
+
+  public static boolean isPolyglotDate_Value(Value val) {
+    return val != null && val.isDate();
+  }
+}

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/BuiltinTypesExposeMethodsTest.java

@@ -0,0 +1,121 @@
+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 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 BuiltinTypesExposeMethodsTest {
+  private static Context ctx;
+
+  private final Value type;
+
+  public BuiltinTypesExposeMethodsTest(Value type) {
+    this.type = type;
+  }
+
+  private static Context ctx() {
+    if (ctx == null) {
+      ctx = ContextUtils.createDefaultContext();
+    }
+    return ctx;
+  }
+
+  @Parameters(name = "{index}: {0}")
+  public static Iterable<Value> generateBuiltinObjects() {
+    var valuesGenerator = ValuesGenerator.create(ctx(), Language.ENSO);
+    var builtinTypes = new ArrayList<Value>();
+    ContextUtils.executeInContext(
+        ctx(),
+        () -> {
+          valuesGenerator.allTypes().stream()
+              .filter(
+                  val -> {
+                    var asType = getType(val);
+                    return !shouldSkipType(asType);
+                  })
+              .forEach(builtinTypes::add);
+          return null;
+        });
+    return builtinTypes;
+  }
+
+  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(type, is(notNullValue()));
+          var typeDefScope = getType(type).getDefinitionScope();
+          var methodsDefinedInScope = typeDefScope.getMethodsForType(getType(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 " + type + " should have members", type.hasMembers(), is(true));
+              assertThat(
+                  "Member " + methodName + " should be present",
+                  type.hasMember(methodName),
+                  is(true));
+              assertThat(
+                  "Member " + methodName + " should be invocable",
+                  type.canInvokeMember(methodName),
+                  is(true));
+            }
+          }
+          return null;
+        });
+  }
+
+  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;
+  }
+}

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

@@ -0,0 +1,78 @@
+package org.enso.interpreter.test.builtins;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+import java.io.ByteArrayOutputStream;
+import org.enso.test.utils.ContextUtils;
+import org.graalvm.polyglot.Context;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class BuiltinsJavaInteropTest {
+  private static Context ctx;
+  private static final ByteArrayOutputStream out = new ByteArrayOutputStream();
+
+  @BeforeClass
+  public static void prepareCtx() {
+    ctx = ContextUtils.createDefaultContext(out);
+  }
+
+  @AfterClass
+  public static void disposeCtx() {
+    ctx.close();
+    ctx = null;
+  }
+
+  @After
+  public void resetOutput() {
+    out.reset();
+  }
+
+  @Test
+  public void javaMethodAcceptsEnsoTimeOfDay_AsObject() {
+    var src =
+        """
+        from Standard.Base import Date_Time
+        polyglot java import org.enso.example.PolyglotTestClass
+
+        main =
+            dt = Date_Time.now
+            PolyglotTestClass.isPolyglotDate_Object dt
+        """;
+    var result = ContextUtils.evalModule(ctx, src);
+    assertThat(result.asBoolean(), is(true));
+  }
+
+  @Test
+  public void javaMethodAcceptsEnsoTimeOfDay_AsLocalDate() {
+    var src =
+        """
+        from Standard.Base import Date_Time
+        polyglot java import org.enso.example.PolyglotTestClass
+
+        main =
+            dt = Date_Time.now
+            PolyglotTestClass.isPolyglotDate_LocalDate dt
+        """;
+    var result = ContextUtils.evalModule(ctx, src);
+    assertThat(result.asBoolean(), is(true));
+  }
+
+  @Test
+  public void javaMethodAcceptsEnsoTimeOfDay_AsValue() {
+    var src =
+        """
+        from Standard.Base import Date_Time
+        polyglot java import org.enso.example.PolyglotTestClass
+
+        main =
+            dt = Date_Time.now
+            PolyglotTestClass.isPolyglotDate_Value dt
+        """;
+    var result = ContextUtils.evalModule(ctx, src);
+    assertThat(result.asBoolean(), is(true));
+  }
+}