Run unit tests with truffle-compiler

engine/runtime-test-instruments/src/main/java/module-info.java

@@ -0,0 +1,9 @@
+module org.enso.runtime.test {
+  requires org.graalvm.truffle;
+
+  exports org.enso.interpreter.test.instruments;
+
+  provides com.oracle.truffle.api.instrumentation.provider.TruffleInstrumentProvider with
+      org.enso.interpreter.test.instruments.CodeIdsTestInstrumentProvider,
+      org.enso.interpreter.test.instruments.CodeLocationsTestInstrumentProvider;
+}

engine/runtime/src/test/java/org/enso/interpreter/test/CodeIdsTestInstrument.java → engine/runtime-test-instruments/src/main/java/org/enso/interpreter/test/instruments/CodeIdsTestInstrument.java

@@ -1,12 +1,12 @@
-package org.enso.interpreter.test;
+package org.enso.interpreter.test.instruments;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.instrumentation.*;
 import com.oracle.truffle.api.nodes.Node;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import org.enso.interpreter.node.ExpressionNode;
-import org.enso.interpreter.runtime.control.TailCallException;
 
 import java.util.UUID;
 
@@ -21,8 +21,24 @@
     services = CodeIdsTestInstrument.class)
 public class CodeIdsTestInstrument extends TruffleInstrument {
   public static final String INSTRUMENT_ID = "ids-test";
+  private static final Class<?> exprNodeClass;
+  private static final Method exprNodeGetId;
+  private static final Class<?> tailCallExceptionClass;
   private Env env;
 
+  /**
+   * Use reflection to call methods from `runtime` project. We cannot use `runtime` as a dependency.
+   */
+  static {
+    try {
+      exprNodeClass = Class.forName("org.enso.interpreter.node.ExpressionNode");
+      exprNodeGetId = exprNodeClass.getMethod("getId");
+      tailCallExceptionClass = Class.forName("org.enso.interpreter.runtime.control.TailCallException");
+    } catch (ClassNotFoundException | NoSuchMethodException e) {
+      throw new AssertionError(e);
+    }
+  }
+
   /**
    * Initializes the instrument. Substitute for a constructor, called by the Truffle framework.
    *
@@ -95,7 +111,6 @@ public void onEnter(VirtualFrame frame) {}
       /**
        * Checks if the node to be executed is the node this listener was created to observe.
        *
-       * @param context current execution context
        * @param frame current execution frame
        * @param result the result of executing the node
        */
@@ -105,11 +120,11 @@ public void onReturnValue(VirtualFrame frame, Object result) {
           return;
         }
         Node node = context.getInstrumentedNode();
-        if (!(node instanceof ExpressionNode)) {
+        if (!(isInstanceOf(node, exprNodeClass))) {
           return;
         }
         nodes.put(this, result);
-        UUID id = ((ExpressionNode) node).getId();
+        UUID id = exprNodeGetId(node);
         if (id == null || !id.equals(expectedId)) {
           return;
         }
@@ -118,6 +133,19 @@ public void onReturnValue(VirtualFrame frame, Object result) {
         }
       }
 
+      private boolean isInstanceOf(Object obj, Class<?> clazz) {
+        return clazz.isInstance(obj);
+      }
+
+      private UUID exprNodeGetId(Object exprNode) {
+        assert isInstanceOf(exprNode, exprNodeClass);
+        try {
+          return (UUID) exprNodeGetId.invoke(exprNode);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+          throw new AssertionError(e);
+        }
+      }
+
       /**
        * Checks if the specified was called, if its execution triggered TCO.
        *
@@ -127,13 +155,13 @@ public void onReturnValue(VirtualFrame frame, Object result) {
        */
       @Override
       public void onReturnExceptional(VirtualFrame frame, Throwable exception) {
-        if (!(exception instanceof TailCallException)) {
+        if (!isInstanceOf(exception, tailCallExceptionClass)) {
           return;
         }
-        if (!(context.getInstrumentedNode() instanceof ExpressionNode)) {
+        if (!isInstanceOf(context.getInstrumentedNode(), exprNodeClass)) {
           return;
         }
-        UUID id = ((ExpressionNode) context.getInstrumentedNode()).getId();
+        UUID id = exprNodeGetId(context.getInstrumentedNode());
         if (expectedResult == null) {
           successful = true;
         }
@@ -143,8 +171,9 @@ public void onReturnExceptional(VirtualFrame frame, Throwable exception) {
       public String toString() {
         var sb = new StringBuilder();
         sb.append(context.getInstrumentedNode().getClass().getSimpleName());
-        if (context.getInstrumentedNode() instanceof ExpressionNode expr) {
-            sb.append("@").append(expr.getId());
+        if (isInstanceOf(context.getInstrumentedNode(), exprNodeClass)) {
+          UUID id = exprNodeGetId(context.getInstrumentedNode());
+          sb.append("@").append(id);
         }
         sb.append(" ");
         sb.append(context.getInstrumentedSourceSection());

engine/runtime/src/test/java/org/enso/interpreter/test/CodeLocationsTestInstrument.java → engine/runtime-test-instruments/src/main/java/org/enso/interpreter/test/instruments/CodeLocationsTestInstrument.java

@@ -1,4 +1,4 @@
-package org.enso.interpreter.test;
+package org.enso.interpreter.test.instruments;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.instrumentation.EventBinding;

engine/runtime-with-instruments/src/test/java/module-info.java

@@ -0,0 +1,6 @@
+open module org.enso.runtime.with.instruments {
+  requires org.enso.runtime;
+  requires org.graalvm.truffle;
+  // TODO: Provides instrument
+
+}

engine/runtime-with-instruments/src/test/scala/org/enso/interpreter/test/instrument/RuntimeProjectContextTest.scala

@@ -44,7 +44,6 @@ class RuntimeProjectContextTest
               .toFile
               .getAbsolutePath
           )
-          .option("engine.WarnInterpreterOnly", "false")
           .option(RuntimeOptions.EDITION_OVERRIDE, "0.0.0-dev")
           .option(RuntimeOptions.LOG_LEVEL, Level.WARNING.getName)
           .logHandler(System.err)

engine/runtime/src/test/scala/org/enso/interpreter/test/InterpreterTest.scala

@@ -1,8 +1,12 @@
 package org.enso.interpreter.test
 
 import com.oracle.truffle.api.instrumentation.EventBinding
-import org.enso.interpreter.test.CodeIdsTestInstrument.IdEventListener
-import org.enso.interpreter.test.CodeLocationsTestInstrument.LocationsEventListener
+import org.enso.interpreter.test.instruments.CodeIdsTestInstrument.IdEventListener
+import org.enso.interpreter.test.instruments.{
+  CodeIdsTestInstrument,
+  CodeLocationsTestInstrument
+}
+import org.enso.interpreter.test.instruments.CodeLocationsTestInstrument.LocationsEventListener
 import org.enso.polyglot.debugger.{
   DebugServerInfo,
   DebuggerSessionManagerEndpoint,

lib/scala/logging-service-logback/src/test/resources/logback-test.xml

@@ -0,0 +1,19 @@
+<configuration>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%logger{36}] -%kvp- %msg%n</pattern>
+    </encoder>
+    <!-- deny all events with a level below WARN, that is INFO, DEBUG and TRACE -->
+    <!-- Accepts only WARN and ERROR -->
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+  </appender>
+
+  <root level="debug">
+    <appender-ref ref="STDOUT" />
+  </root>
+</configuration>

project/JPMSPlugin.scala

@@ -0,0 +1,182 @@
+import sbt.*
+import sbt.Keys.*
+import sbt.internal.inc.{CompileOutput, PlainVirtualFile}
+import sbt.util.CacheStore
+import sbtassembly.Assembly.{Dependency, JarEntry, Project}
+import sbtassembly.{CustomMergeStrategy, MergeStrategy}
+import xsbti.compile.IncToolOptionsUtil
+
+import java.io.File
+
+/** An automatic plugin that handles everything related to JPMS modules. One needs to explicitly
+  * enable this plugin in a project with `.enablePlugins(JPMSPlugin)`. The keys and tasks provided by this plugin
+  * corresponds to the module-related options of `javac` and `java` commands.
+  *
+  * This plugin injects all the module-specific options to `javaOptions`, based on
+  * the settings of this plugin.
+  *
+  * If this plugin is enabled, and no settings/tasks from this plugin are used, then the plugin will
+  * not inject anything into `javaOptions` or `javacOptions`.
+  */
+object JPMSPlugin extends AutoPlugin {
+  object autoImport {
+    val javaModuleName =
+      settingKey[String]("The name of the Java (JPMS) module")
+    val addModules = settingKey[Seq[String]](
+      "Module names that will be added to --add-modules option"
+    )
+    val modulePath = taskKey[Seq[File]](
+      "Directories (Jar archives or expanded Jar archives) that will be put into " +
+      "--module-path option"
+    )
+    val patchModules = taskKey[Map[String, Seq[File]]](
+      """
+        |A map of module names to directories (Jar archives or expanded Jar archives) that will be
+        |put into --patch-module option.
+        |""".stripMargin
+    )
+    val addExports = taskKey[Map[String, Seq[String]]](
+      """
+        |A map of module names to packages that will be put into --add-exports option.
+        |The format of `--add-exports` option is `module/package=target-module(,target-module)*`
+        |The key in the map is `module/package` and the value is a sequence of target modules
+        |""".stripMargin
+    )
+    val addReads = taskKey[Map[String, Seq[String]]](
+      """
+        |A map of module names to modules that will be put into --add-reads option.
+        |When a module A reads a module B, it means that it "depends" on it - it has the same
+        |effect as if module A would have `requires B` in its module-info.java file.
+        |""".stripMargin
+    )
+    val compileModuleInfo = taskKey[Unit]("Compile module-info.java")
+    val modulePathTestOptions_ = taskKey[Seq[String]](
+      "Assembles options for the JVM for running tests with all the required modules. " +
+      "Including truffle-compiler and org.enso.runtime modules and all their dependencies."
+    )
+  }
+
+  import autoImport.*
+
+  override lazy val projectSettings: Seq[Setting[_]] = Seq(
+    addModules := Seq.empty,
+    modulePath := Seq.empty,
+    patchModules := Map.empty,
+    addExports := Map.empty,
+    addReads := Map.empty,
+    compileModuleInfo := {},
+    // javacOptions only inject --module-path and --add-modules, not the rest of the
+    // options.
+    Compile / javacOptions ++= {
+      constructOptions(
+        streams.value.log,
+        modulePath = (Compile / modulePath).value,
+        addModules = (Compile / addModules).value
+      )
+    },
+    Compile / javaOptions ++= {
+      constructOptions(
+        streams.value.log,
+        (Compile / modulePath).value,
+        (Compile / addModules).value,
+        (Compile / patchModules).value,
+        (Compile / addExports).value,
+        (Compile / addReads).value
+      )
+    },
+    Test / javacOptions ++= {
+      constructOptions(
+        streams.value.log,
+        modulePath = (Test / modulePath).value,
+        addModules = (Test / addModules).value
+      )
+    },
+    Test / javaOptions ++= {
+      constructOptions(
+        streams.value.log,
+        (Test / modulePath).value,
+        (Test / addModules).value,
+        (Test / patchModules).value,
+        (Test / addExports).value,
+        (Test / addReads).value
+      )
+    }
+  )
+
+  def constructOptions(
+    log: Logger,
+    modulePath: Seq[File],
+    addModules: Seq[String]              = Seq.empty,
+    patchModules: Map[String, Seq[File]] = Map.empty,
+    addExports: Map[String, Seq[String]] = Map.empty,
+    addReads: Map[String, Seq[String]]   = Map.empty
+  ): Seq[String] = {
+    val patchOpts: Seq[String] = patchModules.flatMap {
+      case (moduleName, dirsToPatch) =>
+        ensureDirectoriesExist(dirsToPatch, log)
+        val patchStr = dirsToPatch
+          .map(_.getAbsolutePath)
+          .mkString(File.pathSeparator)
+        Seq(
+          "--patch-module",
+          s"$moduleName=$patchStr"
+        )
+    }.toSeq
+
+    ensureDirectoriesExist(modulePath, log)
+
+    val addExportsOpts: Seq[String] = addExports.flatMap {
+      case (modPkgName, targetModules) =>
+        if (!modPkgName.contains("/")) {
+          log.error(s"JPMSPlugin: Invalid module/package name: $modPkgName")
+        }
+        Seq(
+          "--add-exports",
+          modPkgName + "=" + targetModules.mkString(",")
+        )
+    }.toSeq
+
+    val modulePathOpts = if (modulePath.isEmpty) {
+      Seq.empty
+    } else {
+      Seq(
+        "--module-path",
+        modulePath.map(_.getAbsolutePath).mkString(File.pathSeparator)
+      )
+    }
+
+    val addModsOpts = if (addModules.isEmpty) {
+      Seq.empty
+    } else {
+      Seq(
+        "--add-modules",
+        addModules.mkString(",")
+      )
+    }
+
+    val addReadsOpts = addReads.flatMap { case (modName, targetModules) =>
+      Seq(
+        "--add-reads",
+        modName + "=" + targetModules.mkString(",")
+      )
+    }.toSeq
+
+    modulePathOpts ++ addModsOpts ++ patchOpts ++ addExportsOpts ++ addReadsOpts
+  }
+
+  /** Java does not mandate that the directories specified in the module path or
+    * in --patch-module exist, but it is usefull to report at least warnings.
+    * @param dirs
+    * @param log
+    */
+  private def ensureDirectoriesExist(
+    dirs: Seq[File],
+    log: Logger
+  ): Unit = {
+    dirs.foreach { dir =>
+      if (!dir.exists()) {
+        log.warn(s"JPMSPlugin: Directory $dir does not exist.")
+      }
+    }
+  }
+}