Recognize if-like Tree.MultiSegmentApp as IfThenElse IR

CHANGELOG.md

@@ -200,6 +200,12 @@
 [11374]: https://github.com/enso-org/enso/pull/11374
 [11671]: https://github.com/enso-org/enso/pull/11671
 
+#### Enso Language & Runtime
+
+- [Unify internal handling of if/then/else and case statement][11365]
+
+[11365]: https://github.com/enso-org/enso/pull/11365
+
 # Enso 2024.4
 
 #### Enso IDE

build.sbt

@@ -2598,7 +2598,18 @@ lazy val publishLocalSetting: SettingsDefinition = Seq(
   packageSrc / publishArtifact := false
 )
 
-def customFrgaalJavaCompilerSettings(targetJdk: String) = {
+def customFrgaalJavaCompilerSettings(
+  targetJdk: String,
+  useSystemPath: Boolean = false
+) = {
+  var opts = Seq(
+    "-source",
+    frgaalSourceLevel,
+    "--enable-preview"
+  )
+  if (useSystemPath) {
+    opts = opts ++ Seq("-XDignore.symbol.file")
+  }
   // There might be slightly different Frgaal compiler configuration for
   // both Compile and Test configurations
   Seq(Compile, Test).flatMap { config =>
@@ -2629,11 +2640,7 @@ def customFrgaalJavaCompilerSettings(targetJdk: String) = {
     // accessible from the non-meta build definition.
     libraryDependencies += FrgaalJavaCompiler.frgaal,
     // Ensure that our tooling uses the right Java version for checking the code.
-    Compile / javacOptions ++= Seq(
-      "-source",
-      frgaalSourceLevel,
-      "--enable-preview"
-    )
+    Compile / javacOptions ++= opts
   )
 }
 
@@ -3441,6 +3448,7 @@ lazy val `runtime-compiler-dump-igv` =
   (project in file("engine/runtime-compiler-dump-igv"))
     .enablePlugins(JPMSPlugin)
     .settings(
+      customFrgaalJavaCompilerSettings("21", true),
       scalaModuleDependencySetting,
       javaModuleName := "org.enso.runtime.compiler.dump.igv",
       Compile / internalModuleDependencies := {

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

@@ -97,17 +97,18 @@ protected IgnoredBindings.State readObject(Input in)
   @org.openide.util.lookup.ServiceProvider(service = Persistance.class)
   public static final class PersistAliasAnalysisGraphScope extends Persistance<Graph.Scope> {
     public PersistAliasAnalysisGraphScope() {
-      super(Graph.Scope.class, false, 1267);
+      super(Graph.Scope.class, false, 1270);
     }
 
     @Override
     @SuppressWarnings("unchecked")
     protected Graph.Scope readObject(Input in) throws IOException {
+      var flatten = in.readBoolean();
       var childScopes = in.readInline(scala.collection.immutable.List.class);
       var occurrencesValues = (scala.collection.immutable.Set<GraphOccurrence>) in.readObject();
       var occurrences = occurrencesValues.map(v -> Tuple2$.MODULE$.apply(v.id(), v)).toMap(null);
       var allDefinitions = in.readInline(scala.collection.immutable.List.class);
-      var parent = new Graph.Scope(childScopes, occurrences, allDefinitions);
+      var parent = new Graph.Scope(flatten, childScopes, occurrences, allDefinitions);
       childScopes.forall(
           (object) -> {
             var ch = (Graph.Scope) object;
@@ -120,6 +121,7 @@ protected Graph.Scope readObject(Input in) throws IOException {
     @Override
     @SuppressWarnings("unchecked")
     protected void writeObject(Graph.Scope obj, Output out) throws IOException {
+      out.writeBoolean(obj.flattenToParent());
       out.writeInline(scala.collection.immutable.List.class, obj.childScopes());
       out.writeObject(obj.occurrences().values().toSet());
       out.writeInline(scala.collection.immutable.List.class, obj.allDefinitions());

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

@@ -18,6 +18,7 @@
 import org.enso.compiler.core.ir.expression.Application;
 import org.enso.compiler.core.ir.expression.Case;
 import org.enso.compiler.core.ir.expression.Comment;
+import org.enso.compiler.core.ir.expression.IfThenElse;
 import org.enso.compiler.core.ir.module.scope.Definition;
 import org.enso.compiler.core.ir.module.scope.definition.*;
 import org.enso.compiler.pass.IRPass;
@@ -206,10 +207,20 @@ public Expression transformExpression(Expression ir) {
           // Note [Call Argument Tail Position]
           p.arguments().foreach(a -> markAsTail(a));
         }
+        case IfThenElse ite -> {
+          if (isInTailPos) {
+            markAsTail(ite);
+            // Note [Analysing Branches in Conditional Expressions]
+            markAsTail(ite.trueBranch());
+            if (ite.falseBranchOrNull() != null) {
+              markAsTail(ite.falseBranchOrNull());
+            }
+          }
+        }
         case Case.Expr e -> {
           if (isInTailPos) {
             markAsTail(ir);
-            // Note [Analysing Branches in Case Expressions]
+            // Note [Analysing Branches in Conditional Expressions]
             e.branches().foreach(b -> markAsTail(b));
           }
         }
@@ -246,6 +257,15 @@ private void collectTailCandidatesExpression(
         Expression expression, java.util.Map<IR, Boolean> tailCandidates) {
       switch (expression) {
         case Function function -> collectTailCandicateFunction(function, tailCandidates);
+        case IfThenElse ite -> {
+          if (isInTailPos) {
+            // Note [Analysing Branches in Conditional Expressions]
+            tailCandidates.put(ite.trueBranch(), true);
+            if (ite.falseBranchOrNull() != null) {
+              tailCandidates.put(ite.falseBranchOrNull(), true);
+            }
+          }
+        }
         case Case caseExpr -> collectTailCandidatesCase(caseExpr, tailCandidates);
         case Application app -> collectTailCandidatesApplication(app, tailCandidates);
         case Name name -> collectTailCandidatesName(name, tailCandidates);
@@ -345,7 +365,7 @@ private void collectTailCandidatesCase(
       switch (caseExpr) {
         case Case.Expr expr -> {
           if (isInTailPos) {
-            // Note [Analysing Branches in Case Expressions]
+            // Note [Analysing Branches in Conditional Expressions]
             expr.branches()
                 .foreach(
                     b -> {
@@ -358,7 +378,7 @@ private void collectTailCandidatesCase(
       }
     }
 
-    /* Note [Analysing Branches in Case Expressions]
+    /* Note [Analysing Branches in Conditional Expressions]
      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      * When performing tail call analysis on a case expression it is very
      * important to recognise that the branches of a case expression should all

engine/runtime-compiler/src/main/java/org/enso/compiler/pass/analyse/alias/graph/GraphBuilder.java

@@ -7,10 +7,12 @@
 public final class GraphBuilder {
   private final Graph graph;
   private final Graph.Scope scope;
+  private final boolean flattenToParent;
 
-  private GraphBuilder(Graph graph, Graph.Scope scope) {
+  private GraphBuilder(Graph graph, Graph.Scope scope, boolean flattenToParent) {
     this.graph = graph;
     this.scope = scope;
+    this.flattenToParent = flattenToParent;
   }
 
   /**
@@ -31,16 +33,27 @@ public static GraphBuilder create() {
    * @return builder operating on the graph {@code g} starting at scope {@code s}
    */
   public static GraphBuilder create(Graph g, Graph.Scope s) {
-    return new GraphBuilder(g, s);
+    return new GraphBuilder(g, s, false);
   }
 
   /**
-   * Creates a child scope and returns a builder for it.
+   * Creates a child scope and returns a builder for it. Same as calling {@link #addChild(boolean)}
+   * with {@code false} argument.
    *
    * @return new builder for newly created scope, but the same graph
    */
   public GraphBuilder addChild() {
-    return new GraphBuilder(graph, scope.addChild());
+    return addChild(false);
+  }
+
+  /**
+   * Creates a child scope and returns a builder for it.
+   *
+   * @param flattenToParent flatten definitions into parent
+   * @return new builder for newly created scope, but the same graph
+   */
+  public GraphBuilder addChild(boolean flattenToParent) {
+    return new GraphBuilder(graph, scope.addChild(flattenToParent), flattenToParent);
   }
 
   /**

engine/runtime-compiler/src/main/scala/org/enso/compiler/context/LocalScope.scala

@@ -58,7 +58,7 @@ class LocalScope(
     log: BiFunction[String, Array[Object], Void]
   ): java.util.List[String] = {
     def symbols(): java.util.List[String] = {
-      val r = scope.allDefinitions.map(_.symbol)
+      val r = scope.allDefinitionsWithFlattened.map(_.symbol)
       r.asJava
     }
     val meta = if (symbolsProvider == null) null else symbolsProvider()
@@ -141,7 +141,7 @@ class LocalScope(
     *         internal slots, that are prepended to every frame.
     */
   private def gatherLocalFrameSlotIdxs(): Map[AliasGraph.Id, Int] = {
-    scope.allDefinitions.zipWithIndex.map { case (definition, i) =>
+    scope.allDefinitionsWithFlattened.zipWithIndex.map { case (definition, i) =>
       definition.id -> (i + LocalScope.internalSlotsSize)
     }.toMap
   }

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

@@ -107,7 +107,19 @@ class PassManager(
         (factory, ctx) => factory.createForModuleCompilation(ctx),
       miniPassCompile = (miniPass, ir) =>
         MiniIRPass.compile[Module](classOf[Module], ir, miniPass),
-      megaPassCompile = (megaPass, ir, ctx) => megaPass.runModule(ir, ctx)
+      megaPassCompile = (megaPass, ir, ctx) =>
+        try {
+          megaPass.runModule(ir, ctx)
+        } catch {
+          case ex: Exception =>
+            val newEx = new IllegalStateException(
+              "Error processing " + ctx.module.getName + "\n" + ex
+                .getClass()
+                .getName() + ": " + ex.getMessage
+            )
+            newEx.setStackTrace(ex.getStackTrace)
+            throw newEx
+        }
     )
   }
 

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/AliasAnalysis.scala

@@ -10,6 +10,7 @@ import org.enso.compiler.core.ir.expression.{
   Case,
   Comment,
   Error,
+  IfThenElse,
   Operator,
   Section
 }
@@ -385,7 +386,8 @@ case object AliasAnalysis extends IRPass {
           isConstructorNameInPatternContext = false,
           builder
         )
-      case cse: Case => analyseCase(cse, builder)
+      case ife: IfThenElse => analyseIfThenElse(ife, builder)
+      case cse: Case       => analyseCase(cse, builder)
       case block: Expression.Block =>
         val currentScope =
           if (!block.suspended) builder else builder.addChild()
@@ -410,7 +412,7 @@ case object AliasAnalysis extends IRPass {
             )
           )
       case binding @ Expression.Binding(name, expression, _, _) =>
-        if (builder.findDef(name.name) == -1) {
+        if (true /* XXX: builder.findDef(name.name) == -1 */ ) {
           val isSuspended = expression match {
             case Expression.Block(_, _, _, isSuspended, _) => isSuspended
             case _                                         => false
@@ -439,7 +441,8 @@ case object AliasAnalysis extends IRPass {
               )
             )
         } else {
-          errors.Redefined.Binding(binding)
+          // errors.Redefined.Binding(binding)
+          binding
         }
       case app: Application =>
         analyseApplication(app, builder)
@@ -756,14 +759,36 @@ case object AliasAnalysis extends IRPass {
     )
   }
 
+  /** Performs alias analysis on a if then else expression.
+    *
+    * @param ir          the expression to analyse
+    * @param builder     the graph builder
+    * @return `ir`, possibly with alias analysis information attached
+    */
+  private def analyseIfThenElse(
+    ir: IfThenElse,
+    builder: GraphBuilder
+  ): IfThenElse = {
+    val condScope  = builder; // .addChild()
+    val trueScope  = builder; // .addChild()
+    val falseScope = builder; // .addChild()
+    ir.copy(
+      cond       = analyseExpression(ir.cond, condScope),
+      trueBranch = analyseExpression(ir.trueBranch, trueScope),
+      falseBranchOrNull = ir.falseBranch.map {
+        analyseExpression(_, falseScope)
+      }.orNull
+    )
+  }
+
   /** Performs alias analysis on a case expression.
     *
     * @param ir          the case expression to analyse
     * @param graph       the graph in which the analysis is taking place
     * @param parentScope the scope in which the case expression occurs
     * @return `ir`, possibly with alias analysis information attached
     */
-  def analyseCase(
+  private def analyseCase(
     ir: Case,
     builder: GraphBuilder
   ): Case = {

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/DataflowAnalysis.scala

@@ -12,6 +12,7 @@ import org.enso.compiler.core.ir.expression.{
   Comment,
   Error,
   Foreign,
+  IfThenElse,
   Operator
 }
 import org.enso.compiler.core.ir.{
@@ -244,6 +245,7 @@ case object DataflowAnalysis extends IRPass {
       case app: Application   => analyseApplication(app, info)
       case typ: Type          => analyseType(typ, info)
       case name: Name         => analyseName(name, info)
+      case ife: IfThenElse    => analyseIfThenElse(ife, info)
       case cse: Case          => analyseCase(cse, info)
       case literal: Literal =>
         literal.updateMetadata(new MetadataPair(this, info))
@@ -580,6 +582,31 @@ case object DataflowAnalysis extends IRPass {
     }
   }
 
+  /** Performs dependency analysis on a if then else expression.
+    *
+    * The value of a if expression is dependent on both its condition and the
+    * definitions of its branches. The computation of the branches also depends
+    * on the condition.
+    *
+    * @param ife the expression
+    * @param info the dependency information for the module
+    * @return `ife`, with attached dependency information
+    */
+  private def analyseIfThenElse(
+    ife: IfThenElse,
+    info: DependencyInfo
+  ): IfThenElse = {
+    val ifeDep  = asStatic(ife)
+    val condDep = asStatic(ife.cond)
+    info.dependents.updateAt(condDep, Set(ifeDep))
+    info.dependencies.updateAt(ifeDep, Set(condDep))
+    ife
+      .copy(
+        cond = analyseExpression(ife.cond, info)
+      )
+      .updateMetadata(new MetadataPair(this, info))
+  }
+
   /** Performs dependency analysis on a case expression.
     *
     * The value of a case expression is dependent on both its scrutinee and the

engine/runtime-compiler/src/main/scala/org/enso/compiler/pass/analyse/DemandAnalysis.scala

@@ -20,6 +20,7 @@ import org.enso.compiler.core.ir.expression.{
   Comment,
   Error,
   Foreign,
+  IfThenElse,
   Operator
 }
 import org.enso.compiler.core.CompilerError
@@ -114,6 +115,8 @@ case object DemandAnalysis extends IRPass {
         analyseApplication(app, isInsideCallArgument)
       case typ: Type =>
         analyseType(typ, isInsideCallArgument)
+      case ite: IfThenElse =>
+        analyseIfThenElse(ite, isInsideCallArgument)
       case cse: Case =>
         analyseCase(cse, isInsideCallArgument)
       case block @ Expression.Block(expressions, retVal, _, _, _) =>
@@ -309,6 +312,25 @@ case object DemandAnalysis extends IRPass {
   ): Type =
     typ.mapExpressions(x => analyseExpression(x, isInsideCallArgument))
 
+  /** Performs demand analysis on an if/then/else expression.
+    *
+    * @param ife the expression
+    * @param isInsideCallArgument whether expression occurs inside a
+    *                             function call argument
+    * @return `cse`, transformed by the demand analysis process
+    */
+  private def analyseIfThenElse(
+    ife: IfThenElse,
+    isInsideCallArgument: Boolean
+  ): IfThenElse = {
+    ife.copy(
+      cond       = analyseExpression(ife.cond, isInsideCallArgument),
+      trueBranch = analyseExpression(ife.trueBranch, false),
+      falseBranchOrNull =
+        ife.falseBranch.map(analyseExpression(_, false)).orNull
+    )
+  }
+
   /** Performs demand analysis on a case expression.
     *
     * @param cse the case expression to perform demand analysis on