Never perform box inference

effekt/jvm/src/test/scala/effekt/ParserTests.scala

@@ -318,7 +318,7 @@ class ParserTests extends munit.FunSuite {
     parseExpr("resume(42)")
     parseExpr("in(42)")
 
-    parseExpr("fun() { foo(()) }")
+    parseExpr("box { foo(()) }")
 
     parseExpr("10.seconds")
 
@@ -338,10 +338,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 }"),
@@ -532,7 +531,7 @@ class ParserTests extends munit.FunSuite {
       """return x;
         |""".stripMargin)
 
-    parseStmts("fun() { x = x + 1; x }")
+    parseStmts("box { x = x + 1; x }")
   }
 
   test("Definition statements") {
@@ -544,7 +543,7 @@ class ParserTests extends munit.FunSuite {
 
     parseStmts("val (left, right) = list; return left")
 
-    parseStmts("val g: () => Unit / Exc at {exc} = fun() { closure() }; ()")
+    parseStmts("val g: () => Unit / Exc at {exc} = box { closure() }; ()")
   }
 
   test("Pattern-matching val parses with correct span") {

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]]

effekt/shared/src/main/scala/effekt/Lexer.scala

@@ -127,13 +127,11 @@ enum TokenKind {
   case `with`
   case `case`
   case `do`
-  case `fun`
   case `match`
   case `def`
   case `extern`
   case `record`
   case `box`
-  case `unbox`
   case `return`
   case `region`
   case `resource`
@@ -178,8 +176,8 @@ object TokenKind {
 
   val keywords = Vector(
     `let`, `true`, `false`, `val`, `var`, `if`, `else`, `while`, `type`, `effect`, `interface`,
-    `try`, `with`, `case`, `do`, `fun`, `match`, `def`, `module`, `import`, `export`, `extern`,
-    `include`, `record`, `box`, `unbox`, `return`, `region`, `resource`, `new`, `and`, `is`,
+    `try`, `with`, `case`, `do`, `match`, `def`, `module`, `import`, `export`, `extern`,
+    `include`, `record`, `box`, `return`, `region`, `resource`, `new`, `and`, `is`,
     `namespace`, `pure`, `private`
   )
 

effekt/shared/src/main/scala/effekt/Namer.scala

@@ -431,7 +431,7 @@ object Namer extends Phase[Parsed, NameResolved] {
         args.foreach(resolve)
       }
 
-    case source.Unbox(term, _) => resolve(term)
+    case source.Unbox(term, _) => resolve(term) // shouldn't occur since unbox is not part of the source
 
     case source.New(impl, _) => resolve(impl)
 
@@ -513,10 +513,6 @@ object Namer extends Phase[Parsed, NameResolved] {
               if !Context.resolveOverloadedOperation(target)
               then Context.abort(pp"Cannot resolve operation ${target}, called on a receiver that is a computation.")
           }
-          // (unbox term).bar(args)  = Invoke(Unbox(term), bar, args)
-          case source.Unbox(term, _) =>
-            if !Context.resolveOverloadedOperation(target)
-            then Context.abort(pp"Cannot resolve operation ${target}, called on an unboxed computation.")
 
           // expr.bar(args) = Call(bar, expr :: args)
           case term =>

effekt/shared/src/main/scala/effekt/Parser.scala

@@ -408,7 +408,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
     some(ident, `/`).mkString("/") labelled "module name"
 
   def isToplevel: Boolean = peek.kind match {
-    case `val` | `fun` | `def` | `type` | `effect` | `namespace` | `interface` | `type` | `record` | `var` | `include` | `extern` => true
+    case `val` | `def` | `type` | `effect` | `namespace` | `interface` | `type` | `record` | `var` | `include` | `extern` => true
     case _ => false
   }
 
@@ -861,16 +861,6 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
       Box(captures, expr, span())
   }
 
-  // TODO deprecate
-  def funExpr(): Term =
-    nonterminal:
-      val blockLiteral = `fun` ~> BlockLiteral(Nil, valueParams().unspan, Nil, braces { stmts(inBraces = true) }, span())
-      Box(Maybe.None(Span(source, pos(), pos(), Synthesized)), blockLiteral, blockLiteral.span.synthesized)
-
-  def unboxExpr(): Term =
-    nonterminal:
-      Unbox(`unbox` ~> expr(), span())
-
   def newExpr(): Term =
     nonterminal:
       New(`new` ~> implementation(), span())
@@ -1183,8 +1173,6 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
     case `try`    => tryExpr()
     case `region` => regionExpr()
     case `box`    => boxExpr()
-    case `unbox`  => unboxExpr()
-    case `fun`    => funExpr()
     case `new`    => newExpr()
     case `do`                => doExpr()
     case _ if isString       => templateString()

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

@@ -80,7 +80,6 @@ class EffektLexers(positions: Positions) extends Parsers(positions) {
   lazy val `with` = keyword("with")
   lazy val `case` = keyword("case")
   lazy val `do` = keyword("do")
-  lazy val `fun` = keyword("fun")
   lazy val `resume` = keyword("resume")
   lazy val `match` = keyword("match")
   lazy val `def` = keyword("def")
@@ -93,7 +92,6 @@ class EffektLexers(positions: Positions) extends Parsers(positions) {
   lazy val `at` = keyword("at")
   lazy val `in` = keyword("in")
   lazy val `box` = keyword("box")
-  lazy val `unbox` = keyword("unbox")
   lazy val `return` = keyword("return")
   lazy val `region` = keyword("region")
   lazy val `resource` = keyword("resource")
@@ -106,7 +104,7 @@ class EffektLexers(positions: Positions) extends Parsers(positions) {
     "def", "let", "val", "var", "true", "false", "else", "type",
     "effect", "interface", "try", "with", "case", "do", "if", "while",
     "match", "module", "import", "extern", "fun",
-    "at", "box", "unbox", "return", "region", "new", "resource", "and", "is", "namespace"
+    "at", "box", "return", "region", "new", "resource", "and", "is", "namespace"
   )
 
   def keyword(kw: String): Parser[String] =
@@ -419,7 +417,6 @@ class CoreParsers(positions: Positions, names: Names) extends EffektLexers(posit
   // ------
   lazy val block: P[Block] =
     ( blockVar
-    | `unbox` ~> pure ^^ Block.Unbox.apply
     | `new` ~> implementation ^^ Block.New.apply
     | blockLit
     // TODO check left associative nesting (also for select)

effekt/shared/src/main/scala/effekt/source/Tree.scala

@@ -533,7 +533,7 @@ enum Term extends Tree {
   case Do(effect: Option[TypeRef], id: IdRef, targs: List[ValueType], vargs: List[ValueArg], bargs: List[Term], span: Span) extends Term, Reference
 
   /**
-   * A call to either an expression, i.e., `(fun() { ...})()`; or a named function, i.e., `foo()`
+   * A call to either an expression, i.e., `(box { () => ... })()`; or a named function, i.e., `foo()`
    */
   case Call(target: CallTarget, targs: List[ValueType], vargs: List[ValueArg], bargs: List[Term], span: Span)
 

effekt/shared/src/main/scala/effekt/typer/BoxUnboxInference.scala → 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 => 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 => 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 => 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
 

effekt/shared/src/main/scala/effekt/util/AnsiHighlight.scala

@@ -59,10 +59,10 @@ object AnsiHighlight {
     // keywords
     case
       `let`  | `val` | `var` | `if` | `else` | `while` |
-      `type` | `effect` | `interface` | `fun` | `do` | `case` | `with` | `try` |
+      `type` | `effect` | `interface` | `do` | `case` | `with` | `try` |
       `true` | `false` |
       `match` | `def` | `module`| `import`| `export`| `extern`| `include`|
-      `record`| `box`| `unbox`| `return`| `region`|
+      `record`| `box`| `return`| `region`|
       `resource`| `new`| `and`| `is`| `namespace`| `pure` => keyword(text)
 
     case _ => text

examples/benchmarks/are_we_fast_yet/bounce.effekt

@@ -16,7 +16,7 @@ def randomBall { rand: Random }: Ball at {global} = {
   val y = ref(toDouble(rand.next().mod(500)));
   val xVel = ref(toDouble(rand.next().mod(300) - 150));
   val yVel = ref(toDouble(rand.next().mod(300) - 150));
-  new Ball {
+  box new Ball {
     def bounce() = {
       val xLimit = 500.0;
       val yLimit = 500.0;

examples/benchmarks/other/generator.effekt

@@ -30,7 +30,7 @@ def generator { prog: => Unit / Yield } {r: Region}: Generator at {prog, r} = {
       cont = box { resume(()) }
     }
   }
-  new Generator {
+  box new Generator {
     def value() = v
     def next() = cont()
   }

examples/benchmarks/other/nbe.effekt

@@ -62,7 +62,7 @@ def reify(v: Value): Term / fresh = v match {
 /// strong normalization of the term
 def normalize(t: Term): Term = {
   var i = 0
-  try reify(eval(empty[Name, Value](compareInt), t))
+  try reify(eval(empty[Name, Value](box compareInt), t))
   with fresh { i = i + 1; resume(i) }
 }
 

examples/benchmarks/other/variadic_combinators.effekt

@@ -41,7 +41,7 @@ def f3(fs: List[=> (Int => Int at {}) at {}]) =
     else first(fs)()(n - 1)
   }
 
-def mod3(x: Int): Int = first(vfix([f1, f2, f3]))()(x)
+def mod3(x: Int): Int = first(vfix([box f1, box f2, box f3]))()(x)
 
 def run(n: Int) = {
   mod3(n) + mod3(n + 1) + mod3(n + 2)

examples/llvm/issue1012.effekt

@@ -7,7 +7,7 @@ def use { g: (Int) => Int } : Int = {
 }
 
 def main() : Unit = {
-  val t = [f]
+  val t = [box f]
   list::map(t) { y => use {y} }
   println("hi")
-}
+}

examples/llvm/nosuchelement.effekt

@@ -9,7 +9,7 @@ def id[A](f: ((A) => Unit at {io, global}) => Unit at {io, global}): ((A) => Uni
 // [error] java.util.NoSuchElementException: key not found: h
 def main() = {
   val f = box { (n: Int) => println(n) }
-  def h = id(g);
+  def h = id(box g);
   val x = h(f);
   println(x)
 }

examples/llvm/prompt-duplication.effekt

@@ -9,8 +9,8 @@ def main() : Unit = {
     } with E { () =>
         def f() = { () }
         def g() = {
-          resume(f)
+          resume(box f)
         }
-        resume(g)
+        resume(box g)
     }
 }

examples/neg/blocks_in_value_pos.check

@@ -2,5 +2,5 @@
   Unit
 but got type
   () => Unit / { MyPrint } at ?C
-    resume(prog);
-           ^^^^
+    resume(box prog);
+           ^^^^^^^^

examples/neg/blocks_in_value_pos.effekt

@@ -4,6 +4,6 @@ effect MyPrint(n: Int): Unit
 
 def main { prog: => Unit / MyPrint } =
   try { prog(); prog() } with MyPrint { (n: Int) =>
-    resume(prog);
+    resume(box prog);
     println(n)
   }

examples/neg/issue362.effekt

@@ -7,5 +7,5 @@ def main() = {
   val cap = try {
     foo {arr}
   } with arr: Exc { def op() = resume(println("hey")) }
-  (unbox cap)()
+  cap()
 }

examples/neg/issue365.check

@@ -1,3 +1,3 @@
 [error] examples/neg/issue365.effekt:8:28: Not allowed {io}
-  val unboxed: Cap at {} = myCap;
-                           ^^^^^
+  val unboxed: Cap at {} = box myCap;
+                           ^^^^^^^^^

examples/neg/issue365.effekt

@@ -5,6 +5,6 @@ extern io def cap(): Cap at {} = default { <> }
 
 def main() = {
   def myCap = cap()
-  val unboxed: Cap at {} = myCap;
+  val unboxed: Cap at {} = box myCap;
   ()
-}
+}

examples/neg/issue50.check

@@ -1,3 +1,3 @@
 [error] examples/neg/issue50.effekt:16:11: Not allowed {Effect2}
-      k = fun (x: Unit) { resume(x) };
-          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      k = box { x => resume(x) };
+          ^^^^^^^^^^^^^^^^^^^^^^

examples/neg/issue50.effekt

@@ -8,19 +8,19 @@ def handle2 { prog: () => Unit / { Effect2 } }: Unit = {
 }
 
 def escape { prog: () => Unit / { Effect1, Effect2 } }: Unit = region this {
-  var k: (Unit) => Unit at { this, prog } in this = fun (x: Unit) { () }
+  var k: (Unit) => Unit at { this, prog } in this = box { x => () }
   handle2 {
     try {
       prog()
     } with Effect1 { () =>
-      k = fun (x: Unit) { resume(x) };
+      k = box { x => resume(x) };
       resume(())
     }
   }
 
-  (unbox k)(())
+  k(())
 }
 
 def main() = {
   escape { do Effect1(); do Effect2() }
-}
+}

examples/neg/issue512.effekt

@@ -6,9 +6,9 @@ def main() = {
   def myref =
     region r1 { // ERROR r1
       var x in r1 = "hoho";
-      new Ref[String] {
+      box new Ref[String] {
         def get() = x
       }
     }
   println(myref.get())
-}
+}

examples/neg/issue548a.effekt

@@ -12,7 +12,7 @@ def withTime[A] { prog: { Time } => A }: A =
 def main() = {
   def b { t: Time }: Time at {t} = box t;  // this is fine
   val cap = withTime {b} // ERROR escape
-  def t2: Time = unbox cap
+  def t2: Time = cap
   t2.now();
   ()
 }