Migrate some passes to Mini passes

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

@@ -0,0 +1,59 @@
+package org.enso.compiler.pass;
+
+import java.util.Set;
+import org.enso.compiler.core.IR;
+import org.enso.compiler.core.ir.ProcessingPass;
+
+/**
+ * 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<T extends IRPass.IRMetadata> implements ProcessingPass {
+
+  /** 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,137 @@
+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.DefinitionArgument;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Module;
+import org.enso.compiler.core.ir.Name;
+import scala.Option;
+
+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 = copyWithNewChildren(ir, transformedChildren);
+    }
+    var transformedIr = miniPass.transformIr(newIr);
+    if (!miniPass.checkPostCondition(transformedIr)) {
+      throw new CompilerError("Post condition failed after applying mini pass " + miniPass);
+    }
+    return transformedIr;
+  }
+
+  /**
+   * Special copy handling of IR elements where the type and the order of children is ambiguous. For
+   * example {@link DefinitionArgument.Specified}.
+   *
+   * @param ir Parent IR.
+   * @param newChildren List of transformed children.
+   * @return Copy of the parent IR with new children.
+   */
+  private static IR copyWithNewChildren(IR ir, scala.collection.immutable.List<IR> newChildren) {
+    return switch (ir) {
+      case DefinitionArgument.Specified defArg -> {
+        if (newChildren.isEmpty()) {
+          throw new IllegalArgumentException("Definition argument must have at least one child");
+        } else if (newChildren.size() == 1) {
+          var newName = (Name) newChildren.apply(0);
+          yield defArg.copy(
+              newName,
+              defArg.ascribedType(),
+              defArg.defaultValue(),
+              defArg.suspended(),
+              defArg.location(),
+              defArg.passData(),
+              defArg.diagnostics(),
+              defArg.id());
+        } else if (newChildren.size() == 2) {
+          var newName = (Name) newChildren.apply(0);
+          var newAscribedTypeOrDefaultVal = (Expression) newChildren.apply(1);
+          if (defArg.ascribedType().isDefined()) {
+            yield defArg.copy(
+                newName,
+                Option.apply(newAscribedTypeOrDefaultVal),
+                defArg.defaultValue(),
+                defArg.suspended(),
+                defArg.location(),
+                defArg.passData(),
+                defArg.diagnostics(),
+                defArg.id());
+          } else if (defArg.defaultValue().isDefined()) {
+            yield defArg.copy(
+                newName,
+                defArg.ascribedType(),
+                Option.apply(newAscribedTypeOrDefaultVal),
+                defArg.suspended(),
+                defArg.location(),
+                defArg.passData(),
+                defArg.diagnostics(),
+                defArg.id());
+          } else {
+            throw new IllegalArgumentException(
+                "Definition argument must have at most two children");
+          }
+        } else if (newChildren.size() == 3) {
+          var newName = (Name) newChildren.apply(0);
+          var newAscribedType = (Expression) newChildren.apply(1);
+          var newDefaultValue = (Expression) newChildren.apply(2);
+          yield defArg.copy(
+              newName,
+              Option.apply(newAscribedType),
+              Option.apply(newDefaultValue),
+              defArg.suspended(),
+              defArg.location(),
+              defArg.passData(),
+              defArg.diagnostics(),
+              defArg.id());
+        } else {
+          throw new IllegalArgumentException(
+              "Definition argument must have at most three children");
+        }
+      }
+      default -> ir.withNewChildren(newChildren);
+    };
+  }
+}

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/LambdaShorthandToLambda.scala

@@ -12,7 +12,7 @@ import org.enso.compiler.core.ir.{
 }
 import org.enso.compiler.core.CompilerError
 import org.enso.compiler.core.ir.expression.{Application, Case, Operator}
-import org.enso.compiler.pass.IRPass
+import org.enso.compiler.pass.{IRPass, MiniPassFactory}
 import org.enso.compiler.pass.analyse.{
   AliasAnalysis,
   DataflowAnalysis,
@@ -35,7 +35,9 @@ import org.enso.compiler.pass.resolve.{
   *
   * - A [[FreshNameSupply]]
   */
-case object LambdaShorthandToLambda extends IRPass {
+case object LambdaShorthandToLambda
+    extends IRPass
+    with MiniPassFactory[LambdaShorthandToLambdaMini] {
   override type Metadata = IRPass.Metadata.Empty
   override type Config   = IRPass.Configuration.Default
 
@@ -434,4 +436,28 @@ case object LambdaShorthandToLambda extends IRPass {
         )
     }
   }
+
+  override def createForModuleCompilation(
+    moduleContext: ModuleContext
+  ): LambdaShorthandToLambdaMini = {
+    val freshNameSupply = moduleContext.freshNameSupply.getOrElse(
+      throw new CompilerError(
+        "Desugaring underscore arguments to lambdas requires a fresh name " +
+        "supply."
+      )
+    )
+    new LambdaShorthandToLambdaMini(freshNameSupply)
+  }
+
+  override def createForInlineCompilation(
+    inlineContext: InlineContext
+  ): LambdaShorthandToLambdaMini = {
+    val freshNameSupply = inlineContext.freshNameSupply.getOrElse(
+      throw new CompilerError(
+        "Desugaring underscore arguments to lambdas requires a fresh name " +
+        "supply."
+      )
+    )
+    new LambdaShorthandToLambdaMini(freshNameSupply)
+  }
 }