More IR mini passes

build.sbt

@@ -2121,6 +2121,7 @@ lazy val `engine-common` = project
   .enablePlugins(JPMSPlugin)
   .settings(
     frgaalJavaCompilerSetting,
+    scalaModuleDependencySetting,
     Test / fork := true,
     commands += WithDebugCommand.withDebug,
     Test / envVars ++= distributionEnvironmentOverrides,
@@ -2908,6 +2909,16 @@ lazy val `runtime-integration-tests` =
           (`runtime` / javaModuleName).value -> Seq(javaSrcDir, testClassesDir)
         )
       },
+      Test / addOpens := {
+        val compilerModName = (`runtime-compiler` / javaModuleName).value
+        // In the tests, we access a private field of org.enso.compiler.pass.PassManager via reflection.
+        Map(
+          compilerModName + "/org.enso.compiler.pass" -> Seq(
+            (`runtime` / javaModuleName).value,
+            "ALL-UNNAMED"
+          )
+        )
+      },
       // runtime-integration-tests does not have module descriptor on its own, so we have
       // to explicitly add some modules to the resolution.
       Test / addModules := Seq(
@@ -3191,7 +3202,8 @@ lazy val `runtime-compiler` =
         "org.yaml"             % "snakeyaml"               % snakeyamlVersion          % Test,
         "org.jline"            % "jline"                   % jlineVersion              % Test,
         "com.typesafe"         % "config"                  % typesafeConfigVersion     % Test,
-        "org.graalvm.polyglot" % "polyglot"                % graalMavenPackagesVersion % Test
+        "org.graalvm.polyglot" % "polyglot"                % graalMavenPackagesVersion % Test,
+        "org.hamcrest"         % "hamcrest-all"            % hamcrestVersion           % Test
       ),
       Compile / moduleDependencies ++= Seq(
         "org.slf4j"        % "slf4j-api"               % slf4jVersion,
@@ -3230,9 +3242,14 @@ lazy val `runtime-compiler` =
         javaModuleName.value
       ),
       Test / patchModules := {
+        // Patch test-classes into the runtime module. This is standard way to deal with the
+        // split package problem in unit tests. For example, Maven's surefire plugin does this.
         val testClassDir = (Test / productDirectories).value.head
+        // Patching with sources is useful for compilation, patching with compiled classes for runtime.
+        val javaSrcDir = (Test / javaSource).value
         Map(
           javaModuleName.value -> Seq(
+            javaSrcDir,
             testClassDir
           )
         )

engine/common/src/main/java/module-info.java

@@ -1,4 +1,5 @@
 module org.enso.engine.common {
+  requires scala.library;
   requires org.graalvm.polyglot;
   requires org.enso.logging.utils;
   requires org.enso.logging.config;

engine/runtime/src/main/java/org/enso/interpreter/util/ScalaConversions.java → engine/common/src/main/java/org/enso/common/ScalaConversions.java

@@ -1,4 +1,4 @@
-package org.enso.interpreter.util;
+package org.enso.common;
 
 import java.util.List;
 import java.util.Optional;

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/ChainedMiniPass.java

@@ -1,8 +1,8 @@
 package org.enso.compiler.pass;
 
-import java.util.Objects;
 import org.enso.compiler.core.IR;
 import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Module;
 
 /** Utility class for chaining mini passes together. */
 final class ChainedMiniPass extends MiniIRPass {
@@ -15,9 +15,8 @@ private ChainedMiniPass(MiniIRPass firstPass, MiniIRPass secondPass) {
   }
 
   static MiniIRPass chain(MiniIRPass firstPass, MiniIRPass secondPass) {
-    if (firstPass == null) {
-      return secondPass;
-    }
+    assert firstPass != null;
+    assert secondPass != null;
     return new ChainedMiniPass(firstPass, secondPass);
   }
 
@@ -39,13 +38,20 @@ public Expression transformExpression(Expression ir) {
     return sndIr;
   }
 
+  @Override
+  public Module transformModule(Module moduleIr) {
+    var first = firstPass.transformModule(moduleIr);
+    var second = secondPass.transformModule(first);
+    return second;
+  }
+
   @Override
   public boolean checkPostCondition(IR ir) {
     return firstPass.checkPostCondition(ir) && secondPass.checkPostCondition(ir);
   }
 
   @Override
   public String toString() {
-    return Objects.toString(firstPass) + ":" + Objects.toString(secondPass);
+    return "{" + firstPass + " + " + secondPass + "}";
   }
 }

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/MiniIRPass.java

@@ -57,7 +57,9 @@ public abstract class MiniIRPass {
    *
    * @param parent the the parent of the edge
    * @param child the child expression element to be be processed.
-   * @return an instance of the pass to process the child's element subtree
+   * @return an instance of the pass to process the child's element subtree. If null is returned,
+   *     the subtree of the child element is not processed, including {@code child} (i.e. {@code
+   *     child} is not processed as well).
    */
   public MiniIRPass prepare(IR parent, Expression child) {
     return this;
@@ -103,10 +105,16 @@ public String toString() {
    * Combines two mini IR passes into one that delegates to both of them.
    *
    * @param first first mini pass (can be {@code null})
-   * @param second second mini pass
+   * @param second second mini pass (can be {@code null})
    * @return a combined pass that calls both non-{@code null} of the provided passes
    */
   public static MiniIRPass combine(MiniIRPass first, MiniIRPass second) {
+    if (first == null && second == null) {
+      return null;
+    }
+    if (first == null) {
+      return second;
+    }
     return ChainedMiniPass.chain(first, second);
   }
 

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/MiniPassFactory.java

@@ -16,7 +16,8 @@ public interface MiniPassFactory extends IRProcessingPass {
    * a module.
    *
    * @param moduleContext A mini pass can optionally save reference to this module context.
-   * @return May return {@code null} if module compilation is not supported.
+   * @return May return {@code null} if module compilation is not supported, or if the compilation
+   *     for the given {@code moduleContext} should be skipped.
    */
   MiniIRPass createForModuleCompilation(ModuleContext moduleContext);
 

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/MiniPassTraverser.java

@@ -71,7 +71,7 @@ static IR compileDeep(IR root, MiniIRPass miniPass) {
    * @param queue queue to put objects in
    * @param ir IR to process
    * @param miniPass process with this mini pass
-   * @return {@code true} if the has been modified with new tries to process first
+   * @return {@code true} if the {@code queue} has been modified with new tries to process first
    */
   private static List<IR> enqueueSubExpressions(
       Collection<MiniPassTraverser> queue, IR ir, MiniIRPass miniPass) {
@@ -81,7 +81,9 @@ private static List<IR> enqueueSubExpressions(
         (ch) -> {
           var preparedMiniPass = miniPass.prepare(ir, ch);
           childExpressions.add(ch);
-          queue.add(new MiniPassTraverser(preparedMiniPass, childExpressions, i[0]++));
+          if (preparedMiniPass != null) {
+            queue.add(new MiniPassTraverser(preparedMiniPass, childExpressions, i[0]++));
+          }
           return ch;
         });
     return childExpressions;

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/ImportSymbolAnalysis.java

@@ -0,0 +1,210 @@
+package org.enso.compiler.pass.analyse;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.enso.common.ScalaConversions;
+import org.enso.compiler.context.InlineContext;
+import org.enso.compiler.context.ModuleContext;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.MetadataStorage;
+import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.core.ir.Name;
+import org.enso.compiler.core.ir.expression.errors.ImportExport;
+import org.enso.compiler.core.ir.module.scope.Import;
+import org.enso.compiler.data.BindingsMap;
+import org.enso.compiler.pass.IRProcessingPass;
+import org.enso.compiler.pass.MiniIRPass;
+import org.enso.compiler.pass.MiniPassFactory;
+import org.enso.compiler.pass.desugar.GenerateMethodBodies$;
+import scala.collection.immutable.Seq;
+import scala.jdk.javaapi.CollectionConverters;
+
+/**
+ * Performs analysis of `from ... import sym1, sym2, ...` statements - checks that all the symbols
+ * imported from the module can be resolved, i.e., exists. In case of unresolved symbols, replaces
+ * the IR import with {@link org.enso.compiler.core.ir.expression.errors.ImportExport}. Reports only
+ * the first unresolved symbol.
+ */
+public class ImportSymbolAnalysis implements MiniPassFactory {
+  public static final ImportSymbolAnalysis INSTANCE = new ImportSymbolAnalysis();
+
+  private ImportSymbolAnalysis() {}
+
+  @Override
+  public Seq<? extends IRProcessingPass> precursorPasses() {
+    List<IRProcessingPass> passes =
+        List.of(BindingAnalysis$.MODULE$, GenerateMethodBodies$.MODULE$);
+    return ScalaConversions.seq(passes);
+  }
+
+  @Override
+  public Seq<? extends IRProcessingPass> invalidatedPasses() {
+    return ScalaConversions.seq(List.of());
+  }
+
+  @Override
+  public MiniIRPass createForModuleCompilation(ModuleContext moduleContext) {
+    var bindingsMap = moduleContext.bindingsAnalysis();
+    assert bindingsMap != null;
+    return new Mini(bindingsMap);
+  }
+
+  @Override
+  public MiniIRPass createForInlineCompilation(InlineContext inlineContext) {
+    var bindingsMap = inlineContext.bindingsAnalysis();
+    return new Mini(bindingsMap);
+  }
+
+  private static final class Mini extends MiniIRPass {
+    private final BindingsMap bindingsMap;
+
+    private Mini(BindingsMap bindingsMap) {
+      this.bindingsMap = bindingsMap;
+    }
+
+    @Override
+    public Module transformModule(Module moduleIr) {
+      var newImports = new ArrayList<Import>();
+      for (var imp : CollectionConverters.asJava(moduleIr.imports())) {
+        if (imp instanceof Import.Module modImp) {
+          var encounteredErrors = analyseSymbolsFromImport(modImp);
+          if (encounteredErrors != null) {
+            newImports.addAll(encounteredErrors);
+            continue;
+          }
+        }
+        newImports.add(imp);
+      }
+      return moduleIr.copy(
+          CollectionConverters.asScala(newImports).toList(),
+          moduleIr.exports(),
+          moduleIr.bindings(),
+          moduleIr.isPrivate(),
+          moduleIr.location(),
+          moduleIr.passData(),
+          moduleIr.diagnostics(),
+          moduleIr.id());
+    }
+
+    @Override
+    public MiniIRPass prepare(IR parent, Expression child) {
+      // return null - do not traverse any children of the root - we just
+      // need to transform the module IR.
+      return null;
+    }
+
+    @Override
+    public Expression transformExpression(Expression expr) {
+      throw new IllegalStateException("Should not be called - prepare returns null");
+    }
+
+    /** Returns list of encountered errors, or null. */
+    private List<Import> analyseSymbolsFromImport(Import.Module imp) {
+      if (imp.onlyNames().isDefined()) {
+        var resolvedImport =
+            bindingsMap.resolvedImports().find(resImp -> resImp.importDef() == imp);
+        if (resolvedImport.isEmpty()) {
+          return null;
+        }
+        var onlyNames = imp.onlyNames().get();
+        var importedTargets = resolvedImport.get().targets();
+        var unresolvedSymbols =
+            importedTargets.flatMap(
+                importedTarget -> onlyNames.filterNot(nm -> isSymbolResolved(importedTarget, nm)));
+        if (unresolvedSymbols.nonEmpty()) {
+          scala.collection.immutable.List<Import> errs =
+              unresolvedSymbols.map(
+                  unresolvedSym ->
+                      createErrorForUnresolvedSymbol(imp, importedTargets.head(), unresolvedSym));
+          return CollectionConverters.asJava(errs);
+        }
+      }
+
+      // Importing symbols from methods is not allowed. The following code checks that if the
+      // import is importing all from a method, an error is reported.
+      if (imp.isAll() && !imp.isSynthetic()) {
+        var resolvedImport =
+            bindingsMap.resolvedImports().find(resImp -> resImp.importDef() == imp);
+        if (resolvedImport.isEmpty()) {
+          return null;
+        }
+        var importedTargets = resolvedImport.get().targets();
+        var encounteredErrors = new ArrayList<Import>();
+        for (var importedTarget : CollectionConverters.asJava(importedTargets)) {
+          switch (importedTarget) {
+            case BindingsMap.ResolvedModuleMethod resModMethod -> {
+              encounteredErrors.add(
+                  createImportFromMethodError(
+                      imp,
+                      resModMethod.module().getName().toString(),
+                      resModMethod.method().name()));
+            }
+            case BindingsMap.ResolvedExtensionMethod extMethod -> {
+              var staticMethod = extMethod.staticMethod();
+              encounteredErrors.add(
+                  createImportFromMethodError(
+                      imp,
+                      extMethod.module().getName().createChild(staticMethod.tpName()).toString(),
+                      staticMethod.methodName()));
+            }
+            case BindingsMap.ResolvedConversionMethod resConvMethod -> {
+              var convMethod = resConvMethod.conversionMethod();
+              var module = resConvMethod.module();
+              encounteredErrors.add(
+                  createImportFromMethodError(
+                      imp,
+                      module.getName().createChild(convMethod.targetTpName()).toString(),
+                      convMethod.methodName()));
+            }
+            default -> {}
+          }
+        }
+        if (!encounteredErrors.isEmpty()) {
+          return encounteredErrors;
+        }
+      }
+      return null;
+    }
+
+    private static boolean isSymbolResolved(
+        BindingsMap.ImportTarget importTarget, Name.Literal symbol) {
+      return importTarget.findExportedSymbolsFor(symbol.name()).nonEmpty();
+    }
+
+    private static ImportExport createErrorForUnresolvedSymbol(
+        Import imp, BindingsMap.ImportTarget importTarget, Name.Literal unresolvedSymbol) {
+      ImportExport.Reason errorReason =
+          switch (importTarget) {
+            case BindingsMap.ResolvedModule resMod -> new ImportExport.SymbolDoesNotExist(
+                unresolvedSymbol.name(), resMod.module().getName().toString());
+            case BindingsMap.ResolvedType resType -> new ImportExport.NoSuchConstructor(
+                resType.tp().name(), unresolvedSymbol.name());
+            case BindingsMap.ResolvedConstructor resCons -> new ImportExport.NoSuchConstructor(
+                resCons.cons().name(), unresolvedSymbol.name());
+            case BindingsMap.ResolvedModuleMethod resMethod -> new ImportExport.NoSuchModuleMethod(
+                resMethod.method().name(), unresolvedSymbol.name());
+            case BindingsMap.ResolvedExtensionMethod extMethod -> new ImportExport
+                .NoSuchStaticMethod(
+                extMethod.module().getName().toString(),
+                extMethod.staticMethod().tpName(),
+                unresolvedSymbol.name());
+            case BindingsMap.ResolvedConversionMethod convMethod -> new ImportExport
+                .NoSuchConversionMethod(
+                convMethod.module().getName().toString(),
+                convMethod.conversionMethod().targetTpName(),
+                convMethod.conversionMethod().sourceTpName());
+            default -> throw new IllegalStateException("Unexpected value: " + importTarget);
+          };
+      return new ImportExport(imp, errorReason, MetadataStorage.EMPTY);
+    }
+
+    private static ImportExport createImportFromMethodError(
+        Import imp, String moduleName, String methodName) {
+      return new ImportExport(
+          imp,
+          new ImportExport.IllegalImportFromMethod(moduleName, methodName),
+          MetadataStorage.EMPTY);
+    }
+  }
+}

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/PrivateModuleAnalysis.java

@@ -37,7 +37,7 @@ private PrivateModuleAnalysis() {}
   @Override
   public Seq<IRProcessingPass> precursorPasses() {
     List<IRProcessingPass> passes =
-        List.of(BindingAnalysis$.MODULE$, ImportSymbolAnalysis$.MODULE$);
+        List.of(BindingAnalysis$.MODULE$, ImportSymbolAnalysis.INSTANCE);
     return CollectionConverters.asScala(passes).toList();
   }
 

engine/runtime-compiler/src/main/scala/org/enso/compiler/Passes.scala

@@ -44,7 +44,7 @@ class Passes(config: CompilerConfig) {
       SectionsToBinOp.INSTANCE,
       OperatorToFunction,
       LambdaShorthandToLambda,
-      ImportSymbolAnalysis,
+      ImportSymbolAnalysis.INSTANCE,
       AmbiguousImportsAnalysis
     ) ++ (if (config.privateCheckEnabled) {
             List(