Run Enso tests with assertions enabled

build.sbt

@@ -1178,11 +1178,6 @@ val truffleRunOpts = Seq(
   "-Dpolyglot.compiler.BackgroundCompilation=false"
 )
 
-val truffleRunOptionsNoAssertSettings = Seq(
-  fork := true,
-  javaOptions ++= benchOnlyOptions
-)
-
 val truffleRunOptionsSettings = Seq(
   fork := true,
   javaOptions ++= "-ea" +: benchOnlyOptions
@@ -1375,11 +1370,20 @@ lazy val instrumentationSettings = frgaalJavaCompilerSetting ++ Seq(
 lazy val `runtime-language-epb` =
   (project in file("engine/runtime-language-epb"))
     .settings(
+      frgaalJavaCompilerSetting,
       inConfig(Compile)(truffleRunOptionsSettings),
       truffleDslSuppressWarnsSetting,
-      instrumentationSettings
+      commands += WithDebugCommand.withDebug,
+      fork := true,
+      Test / javaOptions ++= Seq(),
+      instrumentationSettings,
+      libraryDependencies ++= Seq(
+        "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"
+      )
     )
-    .dependsOn(`polyglot-api`)
 
 lazy val runtime = (project in file("engine/runtime"))
   .configs(Benchmark)
@@ -1727,7 +1731,7 @@ lazy val `runtime-with-polyglot` =
     .configs(Benchmark)
     .settings(
       frgaalJavaCompilerSetting,
-      inConfig(Compile)(truffleRunOptionsNoAssertSettings),
+      inConfig(Compile)(truffleRunOptionsSettings),
       inConfig(Benchmark)(Defaults.testSettings),
       commands += WithDebugCommand.withDebug,
       Benchmark / javacOptions --= Seq(

build/build/src/enso.rs

@@ -30,7 +30,7 @@ impl From<bool> for Boolean {
 }
 
 ide_ci::define_env_var! {
-    ENSO_JVM_OPTS, String;
+    JAVA_OPTS, String;
     ENSO_BENCHMARK_TEST_DRY_RUN, Boolean;
 }
 
@@ -88,7 +88,7 @@ impl BuiltEnso {
             .arg(test_path)
             // This flag enables assertions in the JVM. Some of our stdlib tests had in the past
             // failed on Graal/Truffle assertions, so we want to have them triggered.
-            .set_env(ENSO_JVM_OPTS, &ide_ci::programs::java::Option::EnableAssertions.as_ref())?;
+            .set_env(JAVA_OPTS, &ide_ci::programs::java::Option::EnableAssertions.as_ref())?;
         Ok(command)
     }
 

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/desugar/GenerateMethodBodies.scala

@@ -22,7 +22,6 @@ import org.enso.compiler.pass.analyse.{
 }
 import org.enso.compiler.pass.lint.UnusedBindings
 import org.enso.compiler.pass.optimise.LambdaConsolidate
-import org.enso.polyglot.ForeignLanguage
 
 import scala.annotation.tailrec
 
@@ -161,7 +160,7 @@ case object GenerateMethodBodies extends IRPass {
           case lam @ Function.Lambda(_, body, _, _, _, _)
               if findForeignDefinition(
                 body,
-                lang = Some(ForeignLanguage.JS)
+                lang = Some("js")
               ).isDefined =>
             val thisArgs = chainedFunctionArgs.collect {
               case (arg, idx) if arg.name.name == "this" =>
@@ -308,7 +307,7 @@ case object GenerateMethodBodies extends IRPass {
   @tailrec
   private def findForeignDefinition(
     body: Expression,
-    lang: Option[ForeignLanguage]
+    lang: Option[String]
   ): Option[Foreign.Definition] = {
     body match {
       case foreignDef: Foreign.Definition =>

engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/node/CoercePrimitiveNode.java → engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/CoercePrimitiveNode.java

@@ -1,4 +1,4 @@
-package org.enso.interpreter.epb.node;
+package org.enso.interpreter.epb;
 
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.GenerateUncached;
@@ -10,7 +10,7 @@
 
 @GenerateUncached
 @ReportPolymorphism
-public abstract class CoercePrimitiveNode extends Node {
+abstract class CoercePrimitiveNode extends Node {
 
   /**
    * Create a new node responsible for coercing primitive values to Enso primitives at the polyglot

engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/EpbContext.java

@@ -1,38 +1,38 @@
 package org.enso.interpreter.epb;
 
-import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.TruffleContext;
 import com.oracle.truffle.api.TruffleLanguage;
+import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.nodes.Node;
-import java.util.concurrent.CountDownLatch;
-import java.util.function.Consumer;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.logging.Level;
-import org.enso.interpreter.epb.runtime.GuardedTruffleContext;
 
 /**
  * A context for {@link EpbLanguage}. Provides access to both isolated Truffle contexts used in
  * polyglot execution.
  */
-public class EpbContext {
+final class EpbContext {
 
   private static final TruffleLanguage.ContextReference<EpbContext> REFERENCE =
       TruffleLanguage.ContextReference.create(EpbLanguage.class);
 
   private static final String INNER_OPTION = "isEpbInner";
   private final boolean isInner;
   private final TruffleLanguage.Env env;
-  private @CompilerDirectives.CompilationFinal GuardedTruffleContext innerContext;
-  private final GuardedTruffleContext currentContext;
+  private @CompilationFinal TruffleContext innerContext;
+  private final ReentrantLock lock = new ReentrantLock();
+  private final TruffleLogger log;
 
   /**
    * Creates a new instance of this context.
    *
    * @param env the current language environment.
    */
-  public EpbContext(TruffleLanguage.Env env) {
+  EpbContext(TruffleLanguage.Env env) {
     this.env = env;
     isInner = env.getConfig().get(INNER_OPTION) != null;
-    currentContext = new GuardedTruffleContext(env.getContext(), isInner);
+    this.log = env.getLogger(EpbContext.class);
   }
 
   /**
@@ -45,58 +45,15 @@ public void initialize(String preInitializeLanguages) {
     if (!isInner) {
       if (innerContext == null) {
         innerContext =
-            new GuardedTruffleContext(
-                env.newInnerContextBuilder()
-                    .initializeCreatorContext(true)
-                    .inheritAllAccess(true)
-                    .config(INNER_OPTION, "yes")
-                    .build(),
-                true);
+            env.newInnerContextBuilder()
+                .initializeCreatorContext(true)
+                .inheritAllAccess(true)
+                .config(INNER_OPTION, "yes")
+                .build();
       }
-      initializeLanguages(env, innerContext, preInitializeLanguages);
     }
   }
 
-  private static void initializeLanguages(
-      TruffleLanguage.Env environment, GuardedTruffleContext innerContext, String langs) {
-    if (langs == null || langs.isEmpty()) {
-      return;
-    }
-    var log = environment.getLogger(EpbContext.class);
-    log.log(Level.FINE, "Initializing languages {0}", langs);
-    var cdl = new CountDownLatch(1);
-    var run =
-        (Consumer<TruffleContext>)
-            (context) -> {
-              var lock = innerContext.enter(null);
-              try {
-                log.log(Level.FINEST, "Entering initialization thread");
-                cdl.countDown();
-                for (var l : langs.split(",")) {
-                  log.log(Level.FINEST, "Initializing language {0}", l);
-                  long then = System.currentTimeMillis();
-                  var res = context.initializeInternal(null, l);
-                  long took = System.currentTimeMillis() - then;
-                  log.log(
-                      Level.FINE,
-                      "Done initializing language {0} with {1} in {2} ms",
-                      new Object[] {l, res, took});
-                }
-              } finally {
-                innerContext.leave(null, lock);
-              }
-            };
-    var init = innerContext.createThread(environment, run);
-    log.log(Level.FINEST, "Starting initialization thread");
-    init.start();
-    try {
-      cdl.await();
-    } catch (InterruptedException ex) {
-      Thread.currentThread().interrupt();
-    }
-    log.log(Level.FINEST, "Initializing on background");
-  }
-
   /**
    * @param node the location of context access. Pass {@code null} if not in a node.
    * @return the proper context instance for the current {@link
@@ -106,30 +63,16 @@ public static EpbContext get(Node node) {
     return REFERENCE.get(node);
   }
 
-  /**
-   * Checks if this context corresponds to the inner Truffle context.
-   *
-   * @return true if run in the inner Truffle context, false otherwise.
-   */
-  public boolean isInner() {
-    return isInner;
+  /** @return the language environment associated with this context. */
+  public TruffleLanguage.Env getEnv() {
+    return env;
   }
 
-  /**
-   * @return the inner Truffle context handle if called from the outer context, or null if called in
-   *     the inner context.
-   */
-  public GuardedTruffleContext getInnerContext() {
+  public TruffleContext getInnerContext() {
     return innerContext;
   }
 
-  /** @return returns the currently entered Truffle context handle. */
-  public GuardedTruffleContext getCurrentContext() {
-    return currentContext;
-  }
-
-  /** @return the language environment associated with this context. */
-  public TruffleLanguage.Env getEnv() {
-    return env;
+  public void log(Level level, String msg, Object... args) {
+    this.log.log(level, msg, args);
   }
 }

engine/runtime-language-epb/src/main/java/org/enso/interpreter/epb/EpbLanguage.java

@@ -3,41 +3,17 @@
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.TruffleLanguage;
 import java.util.function.Consumer;
-import org.enso.interpreter.epb.node.ContextRewrapNode;
-import org.enso.interpreter.epb.node.ForeignEvalNode;
-import org.enso.polyglot.ForeignLanguage;
 
-/**
- * An internal language that serves as a bridge between Enso and other supported languages.
- *
- * <p>Truffle places a lot of emphasis on safety guarantees, which also means that single-threaded
- * languages cannot easily be called from multiple threads. We circumvent this by using two separate
- * {@link com.oracle.truffle.api.TruffleContext}s, one (often referred to as "outer") is allowed to
- * run Enso, Host Java, and possibly other thread-ready languages. Languages that cannot safely run
- * in a multithreaded environment are relegated to the other context (referred to as "inner"). The
- * inner context provides a GIL capability, ensuring that access to the single-threaded languages is
- * serialized.
- *
- * <p>This imposes certain limitations on data interchange between the contexts. In particular, it
- * is impossible to execute origin language's code when executing in the other context. Therefore
- * outer context values need to be specially wrapped before being passed (e.g. as arguments) to the
- * inner context, and inner context values need rewrapping for use in the outer context. See {@link
- * org.enso.interpreter.epb.runtime.PolyglotProxy} and {@link ContextRewrapNode} for details of how
- * and when this wrapping is done.
- *
- * <p>With the structure outlined above, EPB is the only language that is initialized in both inner
- * and outer contexts and thus it is very minimal. Its only role is to manage both contexts and
- * provide context-switching facilities.
- */
+/** An internal language that serves as a bridge between Enso and other supported languages. */
 @TruffleLanguage.Registration(
-    id = ForeignLanguage.ID,
+    id = "epb",
     name = "Enso Polyglot Bridge",
     characterMimeTypes = {EpbLanguage.MIME},
     internal = true,
     defaultMimeType = EpbLanguage.MIME,
     contextPolicy = TruffleLanguage.ContextPolicy.SHARED,
     services = Consumer.class)
-public class EpbLanguage extends TruffleLanguage<EpbContext> {
+public final class EpbLanguage extends TruffleLanguage<EpbContext> {
   public static final String MIME = "application/epb";
 
   @Override
@@ -55,9 +31,8 @@ protected void initializeContext(EpbContext context) {
 
   @Override
   protected CallTarget parse(ParsingRequest request) {
-    EpbParser.Result code = EpbParser.parse(request.getSource());
-    ForeignEvalNode foreignEvalNode = ForeignEvalNode.build(this, code, request.getArgumentNames());
-    return foreignEvalNode.getCallTarget();
+    var node = ForeignEvalNode.parse(this, request.getSource(), request.getArgumentNames());
+    return node.getCallTarget();
   }
 
   @Override