Migrate some passes to Mini passes

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

@@ -0,0 +1,58 @@
+package org.enso.compiler.pass;
+
+import java.util.Set;
+import org.enso.compiler.core.IR;
+
+/**
+ * Mini IR pass operates on a single IR element at a time. The {@link org.enso.compiler.Compiler}
+ * traverses the whole IR tree bottom-up from leaves to the root. For each IR element:
+ *
+ * <ol>
+ *   <li>The {@link #prepare(IR)} method is called to prepare the pass for the current IR element.
+ *       This method is called when the {@link org.enso.compiler.Compiler} traverses the element
+ *       from top to bottom. This is useful for mini passes that need to build some information
+ *       about the current IR element before transforming it.
+ *   <li>The {@link #transformIr(IR)} method is called to transform the current IR element. This
+ *       method is called when the {@link org.enso.compiler.Compiler} traverses the element from
+ *       bottom to top. All the children of the current IR element are already transformed when this
+ *       method is called.
+ * </ol>
+ *
+ * <p>Inspired by: <a href="https://dl.acm.org/doi/10.1145/3140587.3062346">Miniphases: compilation
+ * using modular and efficient tree transformations</a>. PDF available at <a
+ * href="https://infoscience.epfl.ch/server/api/core/bitstreams/8ab72c0a-8aa6-4dee-a704-3504938dc316/content">infoscience.epfl.ch</a>
+ */
+public abstract class MiniIRPass {
+
+  /** Set of mini passes that should run before this mini pass. */
+  public Set<MiniIRPass> runsAfter() {
+    return Set.of();
+  }
+
+  /**
+   * Prepare the pass for the provided IR element. This method is called when the {@link
+   * org.enso.compiler.Compiler} traverses the IR element from top to bottom.
+   *
+   * @param ir IR element to be prepared for transformation.
+   */
+  public void prepare(IR ir) {
+    // nop
+  }
+
+  /**
+   * Transform the provided IR element. Children of the IR element are already transformed when this
+   * method is called. This method is called when the {@link org.enso.compiler.Compiler} traverses
+   * the IR element from bottom to top.
+   *
+   * <p>The pass should not do any traversal in this method.
+   *
+   * @param ir IR element to be transformed by this pass.
+   * @return The transformed IR, or the same IR if no transformation is needed. Must not return
+   *     null.
+   */
+  public abstract IR transformIr(IR ir);
+
+  public boolean checkPostCondition(IR ir) {
+    return true;
+  }
+}

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

@@ -0,0 +1,61 @@
+package org.enso.compiler.pass;
+
+import java.util.List;
+import org.enso.compiler.core.IR;
+
+/** Utility class for chaining mini passes together. */
+public final class MiniPassChainer {
+  private MiniPassChainer() {}
+
+  /**
+   * Chains a list of mini passes into a single pass that applies them in order.
+   *
+   * @param passes Ordered list of mini passes.
+   * @return Chained mini pass that applies all the provided mini passes in the given order.
+   */
+  public static MiniIRPass chain(List<MiniIRPass> passes) {
+    return new MiniIRPass() {
+      @Override
+      public void prepare(IR ir) {
+        for (var miniPass : passes) {
+          miniPass.prepare(ir);
+        }
+      }
+
+      @Override
+      public IR transformIr(IR ir) {
+        IR transformedIr = ir;
+        for (var miniPass : passes) {
+          transformedIr = miniPass.transformIr(transformedIr);
+        }
+        return transformedIr;
+      }
+
+      @Override
+      public boolean checkPostCondition(IR ir) {
+        return passes.stream().allMatch(pass -> pass.checkPostCondition(ir));
+      }
+    };
+  }
+
+  public static MiniIRPass chain(MiniIRPass firstPass, MiniIRPass secondPass) {
+    return new MiniIRPass() {
+      @Override
+      public void prepare(IR ir) {
+        firstPass.prepare(ir);
+        secondPass.prepare(ir);
+      }
+
+      @Override
+      public IR transformIr(IR ir) {
+        IR firstResult = firstPass.transformIr(ir);
+        return secondPass.transformIr(firstResult);
+      }
+
+      @Override
+      public boolean checkPostCondition(IR ir) {
+        return firstPass.checkPostCondition(ir) && secondPass.checkPostCondition(ir);
+      }
+    };
+  }
+}

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

@@ -0,0 +1,29 @@
+package org.enso.compiler.pass;
+
+import org.enso.compiler.context.InlineContext;
+import org.enso.compiler.context.ModuleContext;
+
+/**
+ * A collection of factory methods for {@link MiniIRPass IR mini passes}. If a mini pass supports
+ * only inline compilation, its {@link #createForModuleCompilation(ModuleContext)} method should
+ * return null.
+ */
+public interface MiniPassFactory<T extends MiniIRPass> {
+  /**
+   * Creates an instance of mini pass that is capable of transforming IR elements in the context of
+   * a module.
+   *
+   * @param moduleContext A mini pass can optionally save reference to this module context.
+   * @return May return null if module compilation is not supported.
+   */
+  T createForModuleCompilation(ModuleContext moduleContext);
+
+  /**
+   * Creates an instance of mini pass that is capable of transforming IR elements in the context of
+   * an inline compilation.
+   *
+   * @param inlineContext A mini pass can optionally save reference to this inline context.
+   * @return Must not return null. Inline compilation should always be supported.
+   */
+  T createForInlineCompilation(InlineContext inlineContext);
+}

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

@@ -0,0 +1,61 @@
+package org.enso.compiler.pass;
+
+import org.enso.compiler.context.ModuleContext;
+import org.enso.compiler.core.CompilerError;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Module;
+
+public final class MiniPassTraverser {
+  private MiniPassTraverser() {}
+
+  /**
+   * Compiles the whole module with chained {@link MiniIRPass}.
+   *
+   * @param miniPass Mini pass that must support module compilation, i.e., should be created with
+   *     {@link MiniPassFactory#createForModuleCompilation(ModuleContext)}.
+   * @return Transformed module IR.
+   */
+  public static Module compileModuleWithMiniPass(Module moduleIr, MiniIRPass miniPass) {
+    var newModuleIr = compileRecursively(moduleIr, miniPass);
+    return (Module) newModuleIr;
+  }
+
+  public static Expression compileInlineWithMiniPass(Expression exprIr, MiniIRPass miniPass) {
+    miniPass.prepare(exprIr);
+    var newIr = compileRecursively(exprIr, miniPass);
+    if (!miniPass.checkPostCondition(newIr)) {
+      throw new CompilerError("Post condition failed after applying mini pass " + miniPass);
+    }
+    return (Expression) newIr;
+  }
+
+  private static IR compileRecursively(IR ir, MiniIRPass miniPass) {
+    miniPass.prepare(ir);
+    IR newIr;
+    if (ir.children().isEmpty()) {
+      newIr = ir;
+    } else {
+      var transformedChildren =
+          ir.children()
+              .map(
+                  child -> {
+                    var newChild = compileRecursively(child, miniPass);
+                    if (newChild == null) {
+                      throw new IllegalStateException("Mini pass returned null");
+                    }
+                    if (!miniPass.checkPostCondition(newChild)) {
+                      throw new CompilerError(
+                          "Post condition failed after applying mini pass " + miniPass);
+                    }
+                    return newChild;
+                  });
+      newIr = ir.withNewChildren(transformedChildren);
+    }
+    var transformedIr = miniPass.transformIr(newIr);
+    if (!miniPass.checkPostCondition(transformedIr)) {
+      throw new CompilerError("Post condition failed after applying mini pass " + miniPass);
+    }
+    return transformedIr;
+  }
+}

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

@@ -0,0 +1,29 @@
+package org.enso.compiler.pass.desugar;
+
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.CallArgument;
+import org.enso.compiler.core.ir.expression.Application;
+import org.enso.compiler.core.ir.expression.Operator;
+import org.enso.compiler.pass.MiniIRPass;
+import scala.collection.mutable.ListBuffer;
+
+public class OperatorToFunctionMini extends MiniIRPass {
+  OperatorToFunctionMini() {}
+
+  @Override
+  public IR transformIr(IR ir) {
+    if (ir instanceof Operator.Binary binOp) {
+      ListBuffer<CallArgument> args = new ListBuffer<>();
+      args.addOne(binOp.left());
+      args.addOne(binOp.right());
+      return new Application.Prefix(
+          binOp.operator(),
+          args.toList(),
+          false,
+          binOp.location(),
+          binOp.passData(),
+          binOp.diagnostics());
+    }
+    return ir;
+  }
+}

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

@@ -3,7 +3,7 @@ package org.enso.compiler.pass.desugar
 import org.enso.compiler.context.{InlineContext, ModuleContext}
 import org.enso.compiler.core.ir.expression.{Application, Operator}
 import org.enso.compiler.core.ir.{Expression, Module}
-import org.enso.compiler.pass.IRPass
+import org.enso.compiler.pass.{IRPass, MiniPassFactory}
 import org.enso.compiler.pass.analyse.{
   AliasAnalysis,
   DataflowAnalysis,
@@ -16,7 +16,9 @@ import org.enso.compiler.pass.analyse.{
   *
   * - Nothing
   */
-case object OperatorToFunction extends IRPass {
+case object OperatorToFunction
+    extends IRPass
+    with MiniPassFactory[OperatorToFunctionMini] {
 
   /** A purely desugaring pass has no analysis output. */
   override type Metadata = IRPass.Metadata.Empty
@@ -83,4 +85,14 @@ case object OperatorToFunction extends IRPass {
         operatorBinary.diagnostics
       )
     }
+
+  override def createForModuleCompilation(
+    moduleContext: ModuleContext
+  ): OperatorToFunctionMini =
+    new OperatorToFunctionMini()
+
+  override def createForInlineCompilation(
+    inlineContext: InlineContext
+  ): OperatorToFunctionMini =
+    new OperatorToFunctionMini()
 }

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/mini/passes/MiniPassTester.java

@@ -0,0 +1,72 @@
+package org.enso.compiler.test.mini.passes;
+
+import java.io.IOException;
+import org.enso.compiler.PackageRepository;
+import org.enso.compiler.context.FreshNameSupply;
+import org.enso.compiler.context.ModuleContext;
+import org.enso.compiler.core.EnsoParser;
+import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.data.CompilerConfig;
+import org.enso.compiler.pass.IRPass;
+import org.enso.compiler.pass.MiniIRPass;
+import org.enso.compiler.pass.MiniPassFactory;
+import org.enso.compiler.pass.MiniPassTraverser;
+import org.enso.compiler.pass.PassConfiguration;
+import org.enso.compiler.test.CompilerTests;
+import org.enso.pkg.QualifiedName;
+import scala.Option;
+
+/**
+ * A tester class that asserts that a {@link MiniIRPass} has the same result as its corresponding
+ * {@link IRPass} in a module compilation.
+ */
+public abstract class MiniPassTester {
+  protected void compareModuleCompilation(
+      Module ir,
+      ModuleContext moduleContext,
+      IRPass megaPass,
+      MiniPassFactory<? extends MiniIRPass> miniPassFactory) {
+    var miniPass = miniPassFactory.createForModuleCompilation(moduleContext);
+    if (miniPass == null) {
+      throw new IllegalArgumentException("Mini pass does not support module compilation");
+    }
+    var megaPassResult = megaPass.runModule(ir, moduleContext);
+    var miniPassResult = MiniPassTraverser.compileModuleWithMiniPass(ir, miniPass);
+    try {
+      CompilerTests.assertIR(
+          "Mini pass and mega pass results are equal", megaPassResult, miniPassResult);
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  protected Module parse(String code) {
+    try (var parser = new EnsoParser()) {
+      var tree = parser.parse(code);
+      var modIr = parser.generateIR(tree);
+      return modIr;
+    } catch (Exception e) {
+      throw new AssertionError("Failed to parse code", e);
+    }
+  }
+
+  protected ModuleContext buildModuleContext(QualifiedName moduleName) {
+    var compilerConf = defaultCompilerConfig();
+    Option<FreshNameSupply> freshNameSupply = Option.empty();
+    Option<PassConfiguration> passConfig = Option.empty();
+    Option<PackageRepository> pkgRepo = Option.empty();
+    var isGeneratingDocs = false;
+    var runtimeMod = org.enso.interpreter.runtime.Module.empty(moduleName, null);
+    return ModuleContext.apply(
+        runtimeMod.asCompilerModule(),
+        compilerConf,
+        freshNameSupply,
+        passConfig,
+        isGeneratingDocs,
+        pkgRepo);
+  }
+
+  private static CompilerConfig defaultCompilerConfig() {
+    return CompilerConfig.apply(false, true, true, false, false, false, false, Option.empty());
+  }
+}