Fix #971 by updating usages when inlining (#973)

Fixes #971 by:

Before inlining, if the block variable for the function is used more
than once, change usages for all free variables
that are used once to Many. This should be a conservative approximation,
then.

Author: marzipankaiser

effekt/jvm/src/test/scala/effekt/ChezSchemeTests.scala

@@ -26,6 +26,7 @@ abstract class ChezSchemeTests extends EffektTests {
     examplesDir / "pos" / "bidirectional",
     examplesDir / "pos" / "object",
     examplesDir / "pos" / "type_omission_op.effekt",
+    examplesDir / "pos" / "issue972.effekt",
 
     // filesystem operations and bytearrays are not yet supported in our Chez backend
     examplesDir / "benchmarks" / "input_output" / "word_count_ascii.effekt",

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

@@ -187,6 +187,15 @@ object Normalizer { normal =>
     case Stmt.App(b, targs, vargs, bargs) =>
       active(b) match {
         case NormalizedBlock.Known(b: BlockLit, boundBy) if shouldInline(b, boundBy, bargs) =>
+          val blockUsage = boundBy.flatMap { bv => C.usage.get(bv.id) }.getOrElse(Usage.Once)
+          if (blockUsage == Usage.Many) {
+            // This is a conservative approximation:
+            // Since the block is used more than once, we will use the free variables multiple times
+            // after inlining.
+            Variables.free(b).toSet.foreach { v =>
+              C.usage.put(v.id, C.usage.getOrElse(v.id, Usage.Never) * Usage.Many)
+            }
+          }
           reduce(b, targs, vargs.map(normalize), bargs.map(normalize))
         case normalized =>
            Stmt.App(normalized.shared, targs, vargs.map(normalize), bargs.map(normalize))

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

@@ -149,6 +149,16 @@ enum Usage {
     case (Usage.Once, Usage.Many) => Usage.Many
   }
 
+  def *(other: Usage): Usage = (this, other) match {
+    case (Usage.Never, other) => Usage.Never
+    case (other, Usage.Never) => Usage.Never
+    case (Usage.Once, other) => other
+    case (other, Usage.Once) => other
+    case (Usage.Recursive, other) => Usage.Recursive
+    case (other, Usage.Recursive) => Usage.Recursive
+    case _ => Usage.Many
+  }
+
   // -1
   def decrement: Usage = this match {
     case Usage.Never => Usage.Never

examples/pos/issue971.check

@@ -0,0 +1,17 @@
+effect bdeff{ body: => Unit }: Unit
+
+def hnd{ body: => Unit / bdeff }: Unit =
+  try {
+    body()
+  } with bdeff {
+    resume { {b} => b() }
+    resume { {b} => () }
+  }
+
+def main() = {
+  hnd{
+    do bdeff{
+      ()
+    }
+  }
+}

examples/pos/issue971.effekt

@@ -0,0 +1,12 @@
+def hnd{ body: => Unit }: Unit = {
+  def resum{ bod: {=> Unit} => Unit }: Unit = {
+    bod{body}  
+  }
+  resum { {b} => b() }
+  resum { {b} => () }
+}
+def main() = {
+  hnd{
+    ()
+  }
+}

examples/pos/issue971_2.check

@@ -0,0 +1,5 @@
+12
+5
+7
+5
+12

examples/pos/issue971_2.effekt

@@ -0,0 +1,32 @@
+effect exit(): Unit
+effect locally { body: => Unit }: Unit
+
+def scope { body: => Unit / locally }: Unit =
+  try {
+    body()
+  } with locally {
+    try {
+      resume { {b} =>
+        b()
+        exit.exit()
+      }
+    } with exit: exit { () }
+    resume { {b} => if (false) b() } // should be just (), blocked on #971
+  }
+
+def main() = {
+  scope {
+    var x = 12
+    println(x)
+    do locally {
+       x = 5
+       println(x)
+       do locally {
+        x = 7
+        println(x)
+       }
+       println(x)
+    }
+    println(x)
+  }
+}