Recognize if-like Tree.MultiSegmentApp as IfThenElse IR

CHANGELOG.md

@@ -20,6 +20,12 @@
 [11235]: https://github.com/enso-org/enso/pull/11235
 [11255]: https://github.com/enso-org/enso/pull/11255
 
+#### 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

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

@@ -0,0 +1,99 @@
+package org.enso.compiler.pass.desugar;
+
+import java.util.List;
+import org.enso.compiler.context.InlineContext;
+import org.enso.compiler.context.ModuleContext;
+import org.enso.compiler.core.ir.Empty;
+import org.enso.compiler.core.ir.Expression;
+import org.enso.compiler.core.ir.Literal;
+import org.enso.compiler.core.ir.MetadataStorage;
+import org.enso.compiler.core.ir.Name;
+import org.enso.compiler.core.ir.Pattern;
+import org.enso.compiler.core.ir.expression.Case;
+import org.enso.compiler.core.ir.expression.IfThenElse;
+import org.enso.compiler.pass.IRProcessingPass;
+import org.enso.compiler.pass.MiniIRPass;
+import org.enso.compiler.pass.MiniPassFactory;
+import org.enso.compiler.pass.analyse.DemandAnalysis$;
+import scala.Option;
+import scala.collection.immutable.Seq;
+import scala.jdk.javaapi.CollectionConverters;
+
+public final class IfThenElseToCase implements MiniPassFactory {
+
+  public static final IfThenElseToCase INSTANCE = new IfThenElseToCase();
+
+  private IfThenElseToCase() {}
+
+  @Override
+  public Seq<IRProcessingPass> precursorPasses() {
+    List<IRProcessingPass> passes = List.of(GenerateMethodBodies$.MODULE$);
+    return CollectionConverters.asScala(passes).toList();
+  }
+
+  @Override
+  public Seq<IRProcessingPass> invalidatedPasses() {
+    List<IRProcessingPass> passes = List.of(DemandAnalysis$.MODULE$);
+    return CollectionConverters.asScala(passes).toList();
+  }
+
+  @Override
+  public MiniIRPass createForModuleCompilation(ModuleContext moduleContext) {
+    var ctx = InlineContext.fromModuleContext(moduleContext);
+    return new Mini(ctx);
+  }
+
+  @Override
+  public MiniIRPass createForInlineCompilation(InlineContext inlineContext) {
+    return new Mini(inlineContext);
+  }
+
+  private static final class Mini extends MiniIRPass {
+
+    private final InlineContext ctx;
+
+    private Mini(InlineContext ctx) {
+      this.ctx = ctx;
+    }
+
+    @Override
+    public Expression transformExpression(Expression ir) {
+      return switch (ir) {
+        case IfThenElse expr -> {
+          var condArg = expr.cond();
+          var trueAt = expr.trueBranch().identifiedLocation();
+          var falseAt = orNull(expr.falseBranch().map(b -> b.identifiedLocation()));
+          var truePattern =
+              new Pattern.Literal(new Literal.Bool(true, null, meta()), trueAt, meta());
+          var trueBranch = new Case.Branch(truePattern, expr.trueBranch(), true, trueAt, meta());
+          var falseCode =
+              expr.falseBranch().nonEmpty() ? expr.falseBranch().get() : new Empty(null, meta());
+          var falsePattern = new Pattern.Name(new Name.Blank(null, meta()), falseAt, meta());
+          var falseBranch = new Case.Branch(falsePattern, falseCode, true, falseAt, meta());
+          var branches = join(trueBranch, join(falseBranch, nil()));
+          var caseExpr = new Case.Expr(condArg, branches, false, expr.identifiedLocation(), meta());
+          yield caseExpr;
+        }
+        default -> ir;
+      };
+    }
+
+    @SuppressWarnings("unchecked")
+    private static final <T> scala.collection.immutable.List<T> nil() {
+      return (scala.collection.immutable.List<T>) scala.collection.immutable.Nil$.MODULE$;
+    }
+
+    private static final <T> scala.collection.immutable.List<T> join(
+        T head, scala.collection.immutable.List<T> tail) {
+      return scala.collection.immutable.$colon$colon$.MODULE$.apply(head, tail);
+    }
+
+    private static <T> T orNull(Option<T> opt) {
+      return opt.isEmpty() ? null : opt.get();
+    }
+
+    private static MetadataStorage meta() {
+      return new MetadataStorage();
+    }
+  }
+}

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

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

engine/runtime-integration-tests/src/test/java/org/enso/compiler/test/IfThenElseTest.java

@@ -0,0 +1,76 @@
+package org.enso.compiler.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.file.Paths;
+import java.util.logging.Level;
+import org.enso.common.MethodNames;
+import org.enso.common.RuntimeOptions;
+import org.graalvm.polyglot.Context;
+import org.graalvm.polyglot.io.IOAccess;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class IfThenElseTest {
+  private static Context ctx;
+  private static final ByteArrayOutputStream MESSAGES = new ByteArrayOutputStream();
+
+  @BeforeClass
+  public static void initEnsoContext() {
+    ctx =
+        Context.newBuilder()
+            .allowExperimentalOptions(true)
+            .allowIO(IOAccess.ALL)
+            .option(
+                RuntimeOptions.LANGUAGE_HOME_OVERRIDE,
+                Paths.get("../../distribution/component").toFile().getAbsolutePath())
+            .option(RuntimeOptions.STRICT_ERRORS, "true")
+            .option(RuntimeOptions.LOG_LEVEL, Level.WARNING.getName())
+            .logHandler(System.err)
+            .out(MESSAGES)
+            .err(MESSAGES)
+            .allowAllAccess(true)
+            .build();
+    assertNotNull("Enso language is supported", ctx.getEngine().getLanguages().get("enso"));
+  }
+
+  @After
+  public void cleanMessages() {
+    MESSAGES.reset();
+  }
+
+  @AfterClass
+  public static void closeEnsoContext() {
+    ctx.close();
+    ctx = null;
+  }
+
+  @Test
+  public void simpleIfThenElse() throws Exception {
+    var module = ctx.eval("enso", """
+    check x = if x then "Yes" else "No"
+    """);
+
+    var check = module.invokeMember(MethodNames.Module.EVAL_EXPRESSION, "check");
+
+    assertEquals("Yes", check.execute(true).asString());
+    assertEquals("No", check.execute(false).asString());
+  }
+
+  @Test
+  public void simpleIfThen() throws Exception {
+    var module = ctx.eval("enso", """
+    check x = if x then "Yes"
+    """);
+
+    var check = module.invokeMember(MethodNames.Module.EVAL_EXPRESSION, "check");
+
+    assertEquals("Yes", check.execute(true).asString());
+    assertTrue("Expect Nothing", check.execute(false).isNull());
+  }
+}

engine/runtime-parser/src/main/java/org/enso/compiler/core/TreeToIr.java

@@ -25,6 +25,7 @@
 import org.enso.compiler.core.ir.expression.Case;
 import org.enso.compiler.core.ir.expression.Comment;
 import org.enso.compiler.core.ir.expression.Foreign;
+import org.enso.compiler.core.ir.expression.IfThenElse;
 import org.enso.compiler.core.ir.expression.Operator;
 import org.enso.compiler.core.ir.expression.Section;
 import org.enso.compiler.core.ir.expression.errors.Syntax;
@@ -956,6 +957,20 @@ yield translateSyntaxError(l.getExpression().getExpression(),
           sep = "_";
         }
         var fullName = fnName.toString();
+        if ("if_then_else".equals(fullName) && args.size() == 3) {
+          var ifArg = args.apply(2);
+          var trueArg = args.apply(1);
+          var falseArg = args.apply(0);
+          if (falseArg == null) {
+            yield translateSyntaxError(app, new Syntax.UnsupportedSyntax("Missing else branch"));
+          }
+          yield new IfThenElse(ifArg.value(), trueArg.value(), falseArg.value(), getIdentifiedLocation(tree), meta());
+        }
+        if ("if_then".equals(fullName) && args.size() == 2) {
+          var ifArg = args.apply(1);
+          var trueArg = args.apply(0);
+          yield new IfThenElse(ifArg.value(), trueArg.value(), null, getIdentifiedLocation(tree), meta());
+        }
         if (fullName.equals(FREEZE_MACRO_IDENTIFIER)) {
           yield translateExpression(app.getSegments().get(0).getBody(), false);
         } else if (fullName.equals(SKIP_MACRO_IDENTIFIER)) {

engine/runtime-parser/src/main/java/org/enso/compiler/core/ir/IrPersistance.java

@@ -39,12 +39,14 @@
 @Persistable(clazz = Name.Self.class, id = 705)
 @Persistable(clazz = Literal.Number.class, id = 706)
 @Persistable(clazz = Literal.Text.class, id = 707)
-@Persistable(clazz = CallArgument.Specified.class, id = 708)
-@Persistable(clazz = Definition.Type.class, id = 709)
-@Persistable(clazz = Definition.Data.class, id = 710)
-@Persistable(clazz = Name.Blank.class, id = 711)
-@Persistable(clazz = Name.GenericAnnotation.class, id = 712)
-@Persistable(clazz = Name.SelfType.class, id = 713)
+@Persistable(clazz = Literal.Bool.class, id = 708)
+@Persistable(clazz = CallArgument.Specified.class, id = 711)
+@Persistable(clazz = Definition.Type.class, id = 712)
+@Persistable(clazz = Definition.Data.class, id = 713)
+@Persistable(clazz = Name.Blank.class, id = 714)
+@Persistable(clazz = Empty.class, id = 715)
+@Persistable(clazz = Name.GenericAnnotation.class, id = 716)
+@Persistable(clazz = Name.SelfType.class, id = 717)
 @Persistable(clazz = Expression.Block.class, id = 751)
 @Persistable(clazz = Expression.Binding.class, id = 752)
 @Persistable(clazz = Application.Prefix.class, id = 753)

engine/runtime-parser/src/main/scala/org/enso/compiler/core/ir/Literal.scala

@@ -250,4 +250,91 @@ object Literal {
     /** @inheritdoc */
     override def showCode(indent: Int): String = s""""$text""""
   }
+
+  /** A boolean Enso literal.
+    *
+    * @param bool the value of the literal
+    * @param identifiedLocation the source location that the node corresponds to
+    * @param passData the pass metadata associated with this node
+    */
+  sealed case class Bool(
+    bool: Boolean,
+    override val identifiedLocation: IdentifiedLocation,
+    override val passData: MetadataStorage = new MetadataStorage()
+  ) extends Literal
+      with LazyDiagnosticStorage
+      with LazyId {
+
+    /** Creates a copy of `this`.
+      *
+      * @param bool        the boolean value of the literal
+      * @param location    the source location that the node corresponds to
+      * @param passData    the pass metadata associated with this node
+      * @param diagnostics compiler diagnostics for this node
+      * @param id          the identifier for the new node
+      * @return a copy of `this`, updated with the specified values
+      */
+    def copy(
+      bool: Boolean                        = bool,
+      location: Option[IdentifiedLocation] = location,
+      passData: MetadataStorage            = passData,
+      diagnostics: DiagnosticStorage       = diagnostics,
+      id: UUID @Identifier                 = id
+    ): Bool = {
+      if (
+        bool != this.bool
+        || location != this.location
+        || passData != this.passData
+        || diagnostics != this.diagnostics
+        || id != this.id
+      ) {
+        val res = Bool(bool, location.orNull, passData)
+        res.diagnostics = diagnostics
+        res.id          = id
+        res
+      } else this
+    }
+
+    /** @inheritdoc */
+    override def duplicate(
+      keepLocations: Boolean   = true,
+      keepMetadata: Boolean    = true,
+      keepDiagnostics: Boolean = true,
+      keepIdentifiers: Boolean = false
+    ): Bool =
+      copy(
+        location = if (keepLocations) location else None,
+        passData =
+          if (keepMetadata) passData.duplicate else new MetadataStorage(),
+        diagnostics = if (keepDiagnostics) diagnosticsCopy else null,
+        id          = if (keepIdentifiers) id else null
+      )
+
+    /** @inheritdoc */
+    override def setLocation(location: Option[IdentifiedLocation]): Bool =
+      copy(location = location)
+
+    /** @inheritdoc */
+    override def mapExpressions(
+      fn: java.util.function.Function[Expression, Expression]
+    ): Bool = this
+
+    /** String representation. */
+    override def toString: String =
+      s"""
+         |Literal.Bool(
+         |bool = $bool,
+         |location = $location,
+         |passData = ${this.showPassData},
+         |diagnostics = $diagnostics,
+         |id = $id
+         |)
+         |""".toSingleLine
+
+    /** @inheritdoc */
+    override def children: List[IR] = List()
+
+    /** @inheritdoc */
+    override def showCode(indent: Int): String = s"$bool"
+  }
 }