Fix polymorphism boxing for the case of a scrutinee of type Nothing (#1108)

Author: b-studios

effekt/jvm/src/test/scala/effekt/core/OptimizerTests.scala

@@ -36,7 +36,7 @@ class OptimizerTests extends CoreTests {
   def normalize(input: String, expected: String)(using munit.Location) =
     assertTransformsTo(input, expected) { tree =>
       val anfed = BindSubexpressions.transform(tree)
-      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, 50, false)
+      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, 50)
       Deadcode.remove(mainSymbol, normalized)
     }
 

effekt/shared/src/main/scala/effekt/core/PolymorphismBoxing.scala

@@ -232,8 +232,10 @@ object PolymorphismBoxing extends Phase[CoreTransformed, CoreTransformed] {
       Stmt.If(transform(cond), transform(thn), transform(els))
     case Stmt.Match(scrutinee, clauses, default) =>
       scrutinee.tpe match {
-        case ValueType.Data(symbol, targs) =>
-          val Declaration.Data(tpeId, tparams, constructors) = DeclarationContext.getData(symbol)
+        // if the scrutinee has type Nothing, then there shouldn't be any clauses...
+        case Type.TBottom => Stmt.Match(transform(scrutinee), Nil, None)
+        case ValueType.Data(tpeId, targs) =>
+          val Declaration.Data(_, tparams, constructors) = DeclarationContext.getData(tpeId)
           Stmt.Match(transform(scrutinee), clauses.map {
             case (id, clause: Block.BlockLit) =>
               val constructor = constructors.find(_.id == id).get

effekt/shared/src/main/scala/effekt/core/optimizer/Normalizer.scala

@@ -36,7 +36,6 @@ object Normalizer { normal =>
     decls: DeclarationContext,     // for field selection
     usage: mutable.Map[Id, Usage], // mutable in order to add new information after renaming
     maxInlineSize: Int,            // to control inlining and avoid code bloat
-    preserveBoxing: Boolean        // for LLVM, prevents some optimizations
   ) {
     def bind(id: Id, expr: Expr): Context = copy(exprs = exprs + (id -> expr))
     def bind(id: Id, block: Block): Context = copy(blocks = blocks + (id -> block))
@@ -69,14 +68,14 @@ object Normalizer { normal =>
   private def isUnused(id: Id)(using ctx: Context): Boolean =
     ctx.usage.get(id).forall { u => u == Usage.Never }
 
-  def normalize(entrypoints: Set[Id], m: ModuleDecl, maxInlineSize: Int, preserveBoxing: Boolean): ModuleDecl = {
+  def normalize(entrypoints: Set[Id], m: ModuleDecl, maxInlineSize: Int): ModuleDecl = {
     // usage information is used to detect recursive functions (and not inline them)
     val usage = Reachable(entrypoints, m)
 
     val defs = m.definitions.collect {
       case Toplevel.Def(id, block) => id -> block
     }.toMap
-    val context = Context(defs, Map.empty, DeclarationContext(m.declarations, m.externs), mutable.Map.from(usage), maxInlineSize, preserveBoxing)
+    val context = Context(defs, Map.empty, DeclarationContext(m.declarations, m.externs), mutable.Map.from(usage), maxInlineSize)
 
     val (normalizedDefs, _) = normalizeToplevel(m.definitions)(using context)
     m.copy(definitions = normalizedDefs)
@@ -175,7 +174,7 @@ object Normalizer { normal =>
     case Stmt.Let(id, tpe, expr, body) =>
       active(expr) match {
         // [[ val x = ABORT; body ]] = ABORT
-        case abort if !C.preserveBoxing && abort.tpe == Type.TBottom =>
+        case abort if abort.tpe == Type.TBottom =>
           Stmt.Let(id, tpe, abort, Return(ValueVar(id, tpe)))
 
         case normalized =>
@@ -213,6 +212,9 @@ object Normalizer { normal =>
           Stmt.Invoke(normalized.shared, method, methodTpe, targs, vargs.map(normalize), bargs.map(normalize))
       }
 
+    case Stmt.Match(scrutinee, clauses, default) if scrutinee.tpe == Type.TBottom =>
+      Stmt.Return(normalize(scrutinee))
+
     case Stmt.Match(scrutinee, clauses, default) => active(scrutinee) match {
       case Pure.Make(data, tag, targs, vargs) if clauses.exists { case (id, _) => id == tag } =>
         val clause: BlockLit = clauses.collectFirst { case (id, cl) if id == tag => cl }.get
@@ -238,12 +240,17 @@ object Normalizer { normal =>
       def normalizeVal(id: Id, tpe: ValueType, binding: Stmt, body: Stmt): Stmt = normalize(binding) match {
 
         // [[ val x = ABORT; body ]] = ABORT
-        case abort if !C.preserveBoxing && abort.tpe == Type.TBottom  =>
+        case abort if abort.tpe == Type.TBottom  =>
           abort
 
-        case abort @ Stmt.Shift(p, BlockLit(tparams, cparams, vparams, List(k), body))
-            if !C.preserveBoxing && !Variables.free(body).containsBlock(k.id) =>
-          abort
+        // [[ val x: A = shift(p) { {k: A => R} => body2 }; body: B ]] = shift(p) { {k: >>>B<<< => R} => body2 }
+        case abort @ Stmt.Shift(p, BlockLit(tparams, cparams, vparams,
+          BlockParam(k, BlockType.Interface(Type.ResumeSymbol, List(tpeA, answer)), captures) :: Nil, body2))
+              if !Variables.free(body2).containsBlock(k) =>
+            val tpeB = body.tpe
+            Stmt.Shift(p,
+              BlockLit(tparams, cparams, vparams, BlockParam(k, BlockType.Interface(Type.ResumeSymbol, List(tpeB, answer)), captures) :: Nil,
+                normalize(body2)))
 
         // [[ val x = sc match { case id(ps) => body2 }; body ]] = sc match { case id(ps) => val x = body2; body }
         case Stmt.Match(sc, List((id2, BlockLit(tparams2, cparams2, vparams2, bparams2, body2))), None) =>

effekt/shared/src/main/scala/effekt/core/optimizer/Optimizer.scala

@@ -21,8 +21,6 @@ object Optimizer extends Phase[CoreTransformed, CoreTransformed] {
 
   def optimize(source: Source, mainSymbol: symbols.Symbol, core: ModuleDecl)(using Context): ModuleDecl =
 
-    val isLLVM = Context.config.backend().name == "llvm"
-
     var tree = core
 
      // (1) first thing we do is simply remove unused definitions (this speeds up all following analysis and rewrites)
@@ -39,7 +37,7 @@ object Optimizer extends Phase[CoreTransformed, CoreTransformed] {
 
     def normalize(m: ModuleDecl) = {
       val anfed = BindSubexpressions.transform(m)
-      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, Context.config.maxInlineSize().toInt, isLLVM)
+      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, Context.config.maxInlineSize().toInt)
       val live = Deadcode.remove(mainSymbol, normalized)
       val tailRemoved = RemoveTailResumptions(live)
       val contified = DirectStyle.rewrite(tailRemoved)

effekt/shared/src/main/scala/effekt/generator/llvm/LLVM.scala

@@ -39,7 +39,7 @@ class LLVM extends Compiler[String] {
   // The Compilation Pipeline
   // ------------------------
   // Source => Core => Machine => LLVM
-  lazy val Compile = allToCore(Core) andThen Aggregate andThen optimizer.Optimizer andThen core.PolymorphismBoxing andThen Machine map {
+  lazy val Compile = steps.afterCore andThen Machine map {
     case (mod, main, prog) => (mod, llvm.Transformer.transform(prog))
   }
 

examples/llvm/failtooption.effekt

@@ -1,32 +1,27 @@
 effect Fail(): Unit
 
 type OptionInt {
-    None(); Some(i: Int)
-}
-def println(oi: OptionInt): Unit = {
-    oi match {
-        case None() => println("None")
-        case Some(i) => println(i)
-    }
+  None()
+  Some(i: Int)
 }
 
-def runFail{ f : => Int / Fail }: OptionInt = {
-    try {
-        Some(f())
-    } with Fail {
-        None()
-    }
-}
+def println(oi: OptionInt): Unit =
+  oi match {
+    case None() => println("None")
+    case Some(i) => println(i)
+  }
 
-def safeDiv(x: Int, y: Int): Int / Fail = {
-    if(y == 0){
-        do Fail(); 0
-    } else {
-        x/y
-    }
-}
+def runFail { f : => Int / Fail }: OptionInt =
+  try Some(f()) with Fail { None() }
+
+def safeDiv(x: Int, y: Int): Int / Fail =
+  if (y == 0) {
+    do Fail(); 0
+  } else {
+    x / y
+  }
 
 def main() = {
-    println(runFail { safeDiv(6,3) })
-    println(runFail { safeDiv(2,0) })
+  println(runFail { safeDiv(6, 3) })
+  println(runFail { safeDiv(2, 0) })
 }

examples/llvm/matchnothing.check

@@ -0,0 +1 @@
+11

examples/llvm/matchnothing.effekt

@@ -0,0 +1,87 @@
+import args
+
+type Either[A, B] {
+  Left(a: A)
+  Right(b: B)
+}
+
+def enum_from_then_to(from: Int, then: Int, to: Int): List[Int] =
+  if (from <= to) {
+    Cons(from, enum_from_then_to(then, (2 * then) - from, to))
+  } else {
+    Nil()
+  }
+
+def apply_op_inner(ls: List[Int], a: Int) { op: (Int, Int) => Either[Int, Bool] }: List[Either[Int, Bool]] =
+  ls match {
+    case Nil() => Nil()
+    case Cons(b, t2) => Cons(op(a, b), apply_op_inner(t2, a) { op })
+  }
+
+def apply_op(ls: List[Int], astart: Int, astep: Int, alim: Int) { op: (Int, Int) => Either[Int, Bool] }: List[Either[Int, Bool]] =
+  ls match {
+    case Nil() => Nil()
+    case Cons(a, t1) =>
+      append(
+        apply_op_inner(enum_from_then_to(astart, astart + astep, alim), a) { op },
+        apply_op(t1, astart, astep, alim) { op }
+      )
+  }
+
+def integerbench(astart: Int, astep: Int, alim: Int) { op: (Int, Int) => Either[Int, Bool] }: List[Either[Int, Bool]] =
+  apply_op(enum_from_then_to(astart, astart + astep, alim), astart, astep, alim) { op }
+
+def runbench(astart: Int, astep: Int, alim: Int) { jop: (Int, Int) => Either[Int, Bool] }: List[Either[Int, Bool]] = {
+  val res1 = integerbench(astart, astep, alim) { jop }
+  integerbench(astart, astep, alim) { jop }
+}
+
+def runalltests(astart: Int, astep: Int, alim: Int): List[Either[Int, Bool]] = {
+  def z_add(a: Int, b: Int): Either[Int, Bool] = { Left(a + b) }
+  def z_sub(a: Int, b: Int): Either[Int, Bool] = { Left(a - b) }
+  def z_mul(a: Int, b: Int): Either[Int, Bool] = { Left(a * b) }
+  def z_div(a: Int, b: Int): Either[Int, Bool] = { Left(a / b) }
+  def z_mod(a: Int, b: Int): Either[Int, Bool] = { Left(mod(a, b)) }
+  def z_equal(a: Int, b: Int): Either[Int, Bool] = { Right(a == b) }
+  def z_lt(a: Int, b: Int): Either[Int, Bool] = { Right(a < b) }
+  def z_leq(a: Int, b: Int): Either[Int, Bool] = { Right(a <= b) }
+  def z_gt(a: Int, b: Int): Either[Int, Bool] = { Right(a > b) }
+  def z_geq(a: Int, b: Int): Either[Int, Bool] = { Right(a >= b) }
+
+  val add = runbench(astart, astep, alim) { z_add }
+  val sub = runbench(astart, astep, alim) { z_sub }
+  val mul = runbench(astart, astep, alim) { z_mul }
+  val div = runbench(astart, astep, alim) { z_div }
+  val mod = runbench(astart, astep, alim) { z_mod }
+  val equal = runbench(astart, astep, alim) { z_equal }
+  val lt = runbench(astart, astep, alim) { z_lt }
+  val leq = runbench(astart, astep, alim) { z_leq }
+  val gt = runbench(astart, astep, alim) { z_gt }
+  val geq = runbench(astart, astep, alim) { z_geq }
+  runbench(astart, astep, alim) { z_geq }
+}
+
+def test_integer_nofib(n: Int): List[Either[Int, Bool]] =
+  runalltests(-2100000000, n, 2100000000)
+
+def print_either(e: Either[Int, Bool]): Unit =
+  e match {
+    case Left(i) => println(i)
+    case Right(b) =>
+      if (b) {
+        println("11")
+      } else {
+        println("00")
+      }
+  }
+
+def main_loop(iters: Int, n: Int): Unit = {
+  val res = test_integer_nofib(n)
+  if (iters == 1) {
+    print_either(option::getOrElse(list::headOption(res)) { panic("Empty List") })
+  } else {
+    main_loop(iters - 1, n)
+  }
+}
+
+def main() = main_loop(1, 700000001)