Rename phase and fix some tests

b-studios · b-studios · commit ab7fc02d91a2 · 2025-07-22T12:09:25.000+02:00
diff --git a/effekt/jvm/src/test/scala/effekt/ParserTests.scala b/effekt/jvm/src/test/scala/effekt/ParserTests.scala
@@ -335,10 +335,9 @@ class ParserTests extends munit.FunSuite {
 
   test("Boxing") {
     parseExpr("box f")
-    parseExpr("unbox f")
     assertEqualModuloSpans(
-      parseExpr("unbox box f"),
-      parseExpr("unbox (box f)")
+      parseExpr("box f"),
+      parseExpr("(box f)")
     )
     assertNotEqualModuloSpans(
       parseExpr("box { 42 }"),
diff --git a/effekt/shared/src/main/scala/effekt/Compiler.scala b/effekt/shared/src/main/scala/effekt/Compiler.scala
@@ -6,7 +6,7 @@ import effekt.core.Transformer
 import effekt.namer.Namer
 import effekt.source.{AnnotateCaptures, ExplicitCapabilities, ModuleDecl, ResolveExternDefs}
 import effekt.symbols.Module
-import effekt.typer.{BoxUnboxInference, Typer, Wellformedness}
+import effekt.typer.{UnboxInference, Typer, Wellformedness}
 import effekt.util.messages.{CompilerPanic, FatalPhaseError}
 import effekt.util.{SourceTask, Task, VirtualSource, paths}
 import kiama.output.PrettyPrinterTypes.Document
@@ -207,7 +207,7 @@ trait Compiler[Executable] {
        * Explicit box transformation
        * [[NameResolved]] --> [[NameResolved]]
        */
-      BoxUnboxInference andThen
+      UnboxInference andThen
       /**
        * Wellformedness checks (exhaustivity, non-escape)
        * [[Typechecked]] --> [[Typechecked]]
diff --git a/effekt/shared/src/main/scala/effekt/typer/UnboxInference.scala b/effekt/shared/src/main/scala/effekt/typer/UnboxInference.scala
@@ -4,11 +4,11 @@ package typer
 import effekt.context.{ Annotations, Context, ContextOps }
 import effekt.symbols.*
 
-object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
+object UnboxInference extends Phase[NameResolved, NameResolved] {
 
   import source._
 
-  val phaseName = "box-unbox"
+  val phaseName = "unbox"
 
   def run(input: NameResolved)(using Context) = {
     val transformedTree = Context.timed(phaseName, input.source.name) { rewrite(input.tree) }
@@ -52,12 +52,18 @@ object BoxUnboxInference extends Phase[NameResolved, NameResolved] {
     case v: Var => v.definition match {
       // TODO maybe we should synthesize a call to get here already?
       case sym: (ValueSymbol | symbols.RefBinder) => v
-      case sym: BlockSymbol => v //Box(Maybe.None(v.span.emptyAfter), v, v.span.synthesized).inheritPosition(v)
+      case sym: BlockSymbol =>
+        C.error(pp"Computation ${sym} is used in an expression position, which requires boxing (e.g. `box ${sym}`")
+        v
     }
 
-    case n: New => rewriteAsBlock(n) // Box(Maybe.None(n.span.emptyAfter), rewriteAsBlock(n), n.span.synthesized).inheritPosition(n)
+    case n: New =>
+      C.error(pp"Creating an instance in an expression requires boxing (e.g. `box new ${n.impl.id}[...] { ... }`")
+      rewriteAsBlock(n)
 
-    case b: BlockLiteral => rewriteAsBlock(b) // Box(Maybe.None(b.span.emptyAfter), rewriteAsBlock(b), b.span.synthesized).inheritPosition(b)
+    case b: BlockLiteral =>
+      C.error(pp"Function literals in expression position require boxing (e.g. `box { (${b.vparams.map(_.id).mkString(", ")}) => ... `")
+      rewriteAsBlock(b)
 
     case l: Literal => l
 
diff --git a/examples/neg/lambdas/closure.effekt b/examples/neg/lambdas/closure.effekt
@@ -1,10 +1,10 @@
 def twice { someBlock: () => Unit / {} } = {
-  fun() { someBlock(); someBlock() }
+  box { someBlock(); someBlock() }
 }
 effect Yield(): Unit
 def main() = {
   val f = try { // @Yield =>
-    val g = fun(){ do Yield() }
+    val g = box { do Yield() }
     twice {
       def unboxed() = { g() };
       unboxed()// (@Yield)
diff --git a/examples/neg/lambdas/inference.effekt b/examples/neg/lambdas/inference.effekt
@@ -5,11 +5,11 @@ def main() = {
   def hof1(f: (Int) => String at {}): Unit = ()
   def hof2(f: ((Int) => Bool at {}) => String at {}): Unit = ()
 
-  hof2(fun (f: (Int) => Bool at {}) {
+  hof2(box { (f: (Int) => Bool at {}) =>
     f(3);
     ""
   })
 
-  hof2(fun(f: (Int) => Unit at {}) { "" })
-  hof1(fun(b: Bool) { () })
-}
+  hof2(box { (f: (Int) => Unit at {}) => "" })
+  hof1(box { (b: Bool) => () })
+}
diff --git a/examples/pos/bidirectional/scheduler.effekt b/examples/pos/bidirectional/scheduler.effekt
@@ -18,12 +18,12 @@ def scheduler { prog: => Unit / Process } = region this {
   }
   try { prog() } with Process {
     def yield() = {
-      queue = queue.pushFront(fun() { resume(()) })
+      queue = queue.pushFront(box { resume(()) })
     }
     def fork() /* {{() => Unit} => Unit} => Unit */ = {
       queue = queue
-        .pushFront(fun() { resume { {prog: () => Unit} => prog() /* FIX do abort() */ } })
-        .pushFront(fun() { resume { {prog: () => Unit} => () } })
+        .pushFront(box { resume { {prog: () => Unit} => prog() /* FIX do abort() */ } })
+        .pushFront(box { resume { {prog: () => Unit} => () } })
     }
     def exit() /* Nothing => Unit */ = ()
   }
@@ -51,4 +51,4 @@ def main() = {
     do yield()
     println(6)
   }
-}
+}
diff --git a/examples/pos/capture/defdef.effekt b/examples/pos/capture/defdef.effekt
@@ -3,7 +3,7 @@ def myModule { eff : Eff } = region this {
 
   def outer = this;
 
-  val e1 = fun() { eff.use(); () };
+  val e1 = box { eff.use(); () };
   def x = e1;
 
   def test1() = x();
diff --git a/examples/pos/capture/forcing.effekt b/examples/pos/capture/forcing.effekt
@@ -1,9 +1,9 @@
 type NumberThunk = () => Int at {}
 def force(t: NumberThunk): Int = t()
-def init(n: Int): NumberThunk = fun() { n }
-def test(): NumberThunk = fun() {
+def init(n: Int): NumberThunk = box { n }
+def test(): NumberThunk = box {
   val num: Int = (init(42))()
   num
 }
 
-def main() = println(test()())
+def main() = println(test()())
diff --git a/examples/pos/capture/optimizing_unbox.effekt b/examples/pos/capture/optimizing_unbox.effekt
@@ -3,11 +3,11 @@ effect Yield(): Unit
 def main() = try {
 
   val make = {
-    val f = fun() { y.Yield() }
+    val f = box { y.Yield() }
     f
   }
   // here we had the problem that we perform the direct-style "run-optimization", even though make obviously has capture set {y}
   val res = make();
   println(res)
 
-} with y: Yield { () }
+} with y: Yield { () }
diff --git a/examples/pos/capture/selfregion.effekt b/examples/pos/capture/selfregion.effekt
@@ -1,6 +1,6 @@
 def bar {r: Region} = {
   var x in r = 42
-  fun() { x = x + 1; x }
+  box { x = x + 1; x }
 }
 
 def ex1() = region this {
@@ -57,4 +57,4 @@ def main() = {
   ex4();
   ex5();
   ex6()
-}
+}
diff --git a/examples/pos/infer/infer_boxed.effekt b/examples/pos/infer/infer_boxed.effekt
@@ -1,5 +1,5 @@
 def definition() = {
-  val f = fun() { 1 };
+  val f = box { 1 };
   f
 }
 
@@ -10,4 +10,4 @@ def callsite() =
 //  a()
 
 def main() =
-  println(callsite())
+  println(callsite())
diff --git a/examples/pos/infer/infer_effect_polymorphic.effekt b/examples/pos/infer/infer_effect_polymorphic.effekt
@@ -4,7 +4,7 @@ effect Yield(): Unit
 
 def effectPolymorphic() = { //: () => Unit at {effectPolymorphic} / Yield = {
   def local(): Unit = do Yield()
-  fun() { local() }
+  box { local() }
 }
 
 def main() =
diff --git a/examples/pos/issue108.effekt b/examples/pos/issue108.effekt
@@ -31,14 +31,14 @@ def mapping[A, B] {f: A => B} : Unit / {Reduce[A], Iterate[B]} =
   }
 
 def reduce[A, B] {iterator: () => Unit / Iterate[A]} {reducer: () => B / Reduce[A]} = {
-  var coroutine = fun() {Absent()}
-  coroutine = fun() {
+  var coroutine = box { Absent() }
+  coroutine = box {
     try {
       iterator()
       Absent()
     } with Iterate[A] {
       def emit(e) = {
-        coroutine = fun() {resume(())}
+        coroutine = box { resume(()) }
         Present(e)
       }
     }
diff --git a/examples/pos/lambdas/annotated.effekt b/examples/pos/lambdas/annotated.effekt
@@ -3,9 +3,9 @@ effect Exc(): Unit
 def main() =
   try {
     def closure(): Unit = do Exc()
-    val g: () => Unit / Exc at {exc} = fun() { closure() }
+    val g: () => Unit / Exc at {exc} = box { closure() }
     g()
   } with exc: Exc {
     println("exception!");
     resume(())
-  }
+  }
diff --git a/examples/pos/lambdas/effects.effekt b/examples/pos/lambdas/effects.effekt
@@ -3,11 +3,11 @@ interface Get { def get(): Unit }
 interface Yield { def yield(): Unit }
 
 def main() = {
-  val f1: () => Unit / { Exc, Get } at {} = fun() { () };
-  val f2: () => Unit / { Exc, Get } at {} = fun() { do raise() };
-  val f3: () => Unit / { Exc, Get } at {} = fun() { do raise(); do get() };
-  // val f4: () => Unit / { Exc, Get } at {} = fun() { do raise(); do yield() };
+  val f1: () => Unit / { Exc, Get } at {} = box { () };
+  val f2: () => Unit / { Exc, Get } at {} = box { do raise() };
+  val f3: () => Unit / { Exc, Get } at {} = box { do raise(); do get() };
+  // val f4: () => Unit / { Exc, Get } at {} = box { do raise(); do yield() };
   // val f5: () => Unit / { Exc } at {} = f3;
 
   ()
-}
+}
diff --git a/examples/pos/lambdas/generators.effekt b/examples/pos/lambdas/generators.effekt
@@ -13,13 +13,13 @@ def numbers() = {
 
 def main() = region this {
 
-  var generator: () => Result at {this} in this = fun() { Done() }
+  var generator: () => Result at {this} in this = box { Done() }
 
   try {
     numbers()
-    generator = fun() { Done() }
+    generator = box { Done() }
   } with Yield { n =>
-    generator = fun() { resume(()); Next(n) }
+    generator = box { resume(()); Next(n) }
   }
 
   // right now we do not infer unbox for a mutable variable since it
diff --git a/examples/pos/lambdas/higherorder.effekt b/examples/pos/lambdas/higherorder.effekt
@@ -4,15 +4,15 @@ effect Yield(): Unit
 
 def repeater { f: => Unit }: Int => Int at {f} = {
   def rec(n: Int): Int = if (n == 0) { f(); n } else rec(n - 1)
-  fun(n: Int) { rec(n) }
+  box { n => rec(n) }
 }
 
 
 def main() =
   try {
     val repeat = repeater { do Yield(); println("hello") };
     def closure(): Int = repeat(3);
-    val g = fun(n: Int) { closure(); n + 1 }
+    val g = box { (n: Int) => closure(); n + 1 }
     def unboxed() = g(1);
     unboxed();
     ()
diff --git a/examples/pos/lambdas/localstate.effekt b/examples/pos/lambdas/localstate.effekt
@@ -7,7 +7,7 @@ def main() = {
 
     def count1(n: Int): Int = if (n == 0) n else count1(n - 1)
 
-    def hof { g2 : => Unit } = fun () {
+    def hof { g2 : => Unit } = box {
       x = x + 1
       println(x + y); g2()
     }
@@ -22,4 +22,4 @@ def main() = {
     ()
   }
   local()
-}
+}
diff --git a/examples/pos/lambdas/scheduler.effekt b/examples/pos/lambdas/scheduler.effekt
@@ -20,12 +20,12 @@ def scheduler { prog: => Unit / Proc } = region this {
   }
   try { prog() } with Proc {
     def yield() = {
-      queue = queue.pushFront(fun() { resume(()) })
+      queue = queue.pushFront(box { resume(()) })
     }
     def fork() = {
       queue = queue
-        .pushFront(fun() { resume(true) })
-        .pushFront(fun() { resume(false) })
+        .pushFront(box { resume(true) })
+        .pushFront(box { resume(false) })
     }
     def exit() = ()
   }
@@ -57,4 +57,4 @@ def main() = {
       println(6)
     }
   }
-}
+}
diff --git a/examples/pos/lambdas/simpleclosure.effekt b/examples/pos/lambdas/simpleclosure.effekt
@@ -14,14 +14,14 @@ def main() = {
       // since `block` closes over `Raise` we have to make sure that
       // it cannot leave the outer `try`.
       if (do Flip()) {
-        fun() { block("first") }
+        box { block("first") }
       } else {
-        fun() { block("second") }
+        box { block("second") }
       }
     } with Flip {
       // the continuation itself transitively closes over `block` and `Raise`.
       // it also must not leave the scope of Raise.
-      val h: () => Unit at {raise} = fun() { (resume(true))(); (resume(false))() }
+      val h: () => Unit at {raise} = box { (resume(true))(); (resume(false))() }
       h
     }
 

Original file line number	Diff line number	Diff line change
`@@ -18,12 +18,12 @@ def scheduler { prog: => Unit / Process } = region this {`
`18`	`18`	`}`
`19`	`19`	`try { prog() } with Process {`
`20`	`20`	`def yield() = {`
`21`		`- queue = queue.pushFront(fun() { resume(()) })`
	`21`	`+ queue = queue.pushFront(box { resume(()) })`
`22`	`22`	`}`
`23`	`23`	`def fork() /* {{() => Unit} => Unit} => Unit */ = {`
`24`	`24`	`queue = queue`
`25`		`- .pushFront(fun() { resume { {prog: () => Unit} => prog() /* FIX do abort() */ } })`
`26`		`- .pushFront(fun() { resume { {prog: () => Unit} => () } })`
	`25`	`+ .pushFront(box { resume { {prog: () => Unit} => prog() /* FIX do abort() */ } })`
	`26`	`+ .pushFront(box { resume { {prog: () => Unit} => () } })`
`27`	`27`	`}`
`28`	`28`	`def exit() /* Nothing => Unit */ = ()`
`29`	`29`	`}`
`@@ -51,4 +51,4 @@ def main() = {`
`51`	`51`	`do yield()`
`52`	`52`	`println(6)`
`53`	`53`	`}`
`54`		`-}`
	`54`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -3,11 +3,11 @@ effect Yield(): Unit`
`3`	`3`	`def main() = try {`
`4`	`4`
`5`	`5`	`val make = {`
`6`		`- val f = fun() { y.Yield() }`
	`6`	`+ val f = box { y.Yield() }`
`7`	`7`	`f`
`8`	`8`	`}`
`9`	`9`	`// here we had the problem that we perform the direct-style "run-optimization", even though make obviously has capture set {y}`
`10`	`10`	`val res = make();`
`11`	`11`	`println(res)`
`12`	`12`
`13`		`-} with y: Yield { () }`
	`13`	`+} with y: Yield { () }`