Towards a ClassPath per Package

Author: JaroslavTulach

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/interop/java/AddToClassPathNode.java

@@ -5,6 +5,7 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.nodes.Node;
 import java.io.File;
+import java.util.Collections;
 import org.enso.interpreter.dsl.BuiltinMethod;
 import org.enso.interpreter.node.expression.builtin.text.util.ExpectStringNode;
 import org.enso.interpreter.runtime.EnsoContext;
@@ -27,7 +28,7 @@ static AddToClassPathNode build() {
   Object doExecute(Object path, @Cached ExpectStringNode expectStringNode) {
     var ctx = EnsoContext.get(this);
     var file = ctx.getTruffleFile(new File(expectStringNode.execute(path)));
-    ctx.addToClassPath(file);
+    ctx.createClassPath(Collections.singletonList(file));
     return ctx.getBuiltins().nothing();
   }
 }

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/interop/java/LookupClassNode.java

@@ -21,7 +21,7 @@ static LookupClassNode build() {
   @Specialization
   @CompilerDirectives.TruffleBoundary
   Object doExecute(Object name, @Cached("build()") ExpectStringNode expectStringNode) {
-    return EnsoContext.get(this).lookupJavaClass(expectStringNode.execute(name));
+    return EnsoContext.get(this).lookupJavaClass(null, expectStringNode.execute(name));
   }
 
   abstract Object execute(Object name);

engine/runtime/src/main/java/org/enso/interpreter/runtime/EnsoContext.java

@@ -28,6 +28,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -424,28 +425,42 @@ public Optional<Module> findModuleByExpressionId(UUID expressionId) {
   }
 
   /**
-   * Modifies the classpath to use to lookup {@code polyglot java} imports.
+   * Creates a class path. A class path is capable to load Java classes in an isolated manner.
    *
-   * @param file the file to register
+   * @param files files to register
    */
   @TruffleBoundary
-  public void addToClassPath(TruffleFile file) {
-    if (findGuestJava() == null) {
-      try {
-        var url = file.toUri().toURL();
-        hostClassLoader.add(url);
-      } catch (MalformedURLException ex) {
-        throw new IllegalStateException(ex);
+  public EnsoClassPath createClassPath(List<TruffleFile> files) {
+    return new EnsoClassPath(files);
+  }
+
+  public final class EnsoClassPath {
+    //    private final TruffleFile[] files;
+
+    private EnsoClassPath(List<TruffleFile> files) {
+      for (var f : files) {
+        add(f);
       }
-    } else {
-      try {
-        var path = new File(file.toUri()).getAbsoluteFile();
-        if (!path.exists()) {
-          throw new IllegalStateException("File not found " + path);
+    }
+
+    private void add(TruffleFile file) {
+      if (findGuestJava() == null) {
+        try {
+          var url = file.toUri().toURL();
+          hostClassLoader.add(url);
+        } catch (MalformedURLException ex) {
+          throw new IllegalStateException(ex);
+        }
+      } else {
+        try {
+          var path = new File(file.toUri()).getAbsoluteFile();
+          if (!path.exists()) {
+            throw new IllegalStateException("File not found " + path);
+          }
+          InteropLibrary.getUncached().invokeMember(findGuestJava(), "addPath", path.getPath());
+        } catch (InteropException ex) {
+          throw new IllegalStateException(ex);
         }
-        InteropLibrary.getUncached().invokeMember(findGuestJava(), "addPath", path.getPath());
-      } catch (InteropException ex) {
-        throw new IllegalStateException(ex);
       }
     }
   }
@@ -518,11 +533,12 @@ public boolean isColorTerminalOutput() {
    * resolves to an inner class, then the import of the outer class is resolved, and the inner class
    * is looked up by iterating the members of the outer class via Truffle's interop protocol.
    *
+   * @param pkg Enso package to load the class for
    * @param className Fully qualified class name, can also be nested static inner class.
    * @return If the java class is found, return it, otherwise return null.
    */
   @TruffleBoundary
-  public Object lookupJavaClass(String className) {
+  public Object lookupJavaClass(Package<?> pkg, String className) {
     var binaryName = new StringBuilder(className);
     var collectedExceptions = new ArrayList<Exception>();
     for (; ; ) {

engine/runtime/src/main/java/org/enso/interpreter/runtime/TruffleCompilerContext.java

@@ -147,7 +147,7 @@ public void truffleRunCodegen(
     var s =
         org.enso.interpreter.runtime.scope.ModuleScope.Builder.fromCompilerModuleScopeBuilder(
             scopeBuilder);
-    new IrToTruffle(context, m.getSource(), s, config).run(module.getIr());
+    new IrToTruffle(context, m.getSource(), s, config).run(module.getPackage(), module.getIr());
   }
 
   // module related

engine/runtime/src/main/scala/org/enso/interpreter/runtime/DefaultPackageRepository.scala

@@ -197,7 +197,7 @@ private class DefaultPackageRepository(
     isLibrary: Boolean
   ): Unit = {
     val extensions = pkg.listPolyglotExtensions("java")
-    extensions.foreach(context.addToClassPath)
+    context.createClassPath(extensions.asJava)
 
     val (regularModules, syntheticModulesMetadata) = pkg
       .listSources()

engine/runtime/src/main/scala/org/enso/interpreter/runtime/IrToTruffle.scala

@@ -153,7 +153,7 @@ class IrToTruffle(
     *
     * @param ir the IR to generate code for
     */
-  def run(ir: Module): Unit = processModule(ir)
+  def run(p: org.enso.pkg.Package[_], ir: Module): Unit = processModule(p, ir)
 
   /** Executes the codegen pass on an inline input.
     *
@@ -186,7 +186,10 @@ class IrToTruffle(
     *
     * @param module the module for which code should be generated
     */
-  private def processModule(module: Module): Unit = {
+  private def processModule(
+    p: org.enso.pkg.Package[_],
+    module: Module
+  ): Unit = {
     generateReExportBindings(module)
     val bindingsMap =
       module
@@ -197,7 +200,7 @@ class IrToTruffle(
 
     registerModuleExports(bindingsMap)
     registerModuleImports(bindingsMap)
-    registerPolyglotImports(module)
+    registerPolyglotImports(p, module)
 
     registerTypeDefinitions(module)
     registerMethodDefinitions(module)
@@ -232,10 +235,13 @@ class IrToTruffle(
       }
     }
 
-  private def registerPolyglotImports(module: Module): Unit =
+  private def registerPolyglotImports(
+    p: org.enso.pkg.Package[_],
+    module: Module
+  ): Unit =
     module.imports.foreach {
       case poly @ imports.Polyglot(i: imports.Polyglot.Java, _, _, _, _) =>
-        var hostSymbol = context.lookupJavaClass(i.getJavaName)
+        var hostSymbol = context.lookupJavaClass(p, i.getJavaName)
         if (hostSymbol == null) {
           val err = Text.create(
             s"Incorrect polyglot java import: ${i.getJavaName}"