Fix failing tests without optimization

effekt/jvm/src/test/scala/effekt/JavaScriptTests.scala

@@ -26,14 +26,12 @@ class JavaScriptTests extends EffektTests {
 
   override lazy val withoutOptimizations: List[File] = List(
     // contifying under reset
-    //examplesDir / "pos" / "issue842.effekt",
-    //examplesDir / "pos" / "issue861.effekt",
+    examplesDir / "pos" / "issue842.effekt",
+    examplesDir / "pos" / "issue861.effekt",
 
     // syntax error (multiple declaration)
-    //examplesDir / "char" / "ascii_isalphanumeric.effekt",
-    //examplesDir / "char" / "ascii_iswhitespace.effekt",
-    //examplesDir / "pos" / "parser.effekt",
-    //examplesDir / "pos" / "probabilistic.effekt",
+    examplesDir / "pos" / "parser.effekt",
+    examplesDir / "pos" / "probabilistic.effekt",
   )
 
   override def ignored: List[File] = List(

effekt/jvm/src/test/scala/effekt/LLVMTests.scala

@@ -55,8 +55,15 @@ class LLVMTests extends EffektTests {
 
   override lazy val withoutOptimizations: List[File] = List(
     // contifying under reset
-    //examplesDir / "pos" / "issue842.effekt",
-    //examplesDir / "pos" / "issue861.effekt",
+    examplesDir / "pos" / "issue842.effekt",
+    examplesDir / "pos" / "issue861.effekt",
+
+    examplesDir / "pos" / "capture" / "regions.effekt",
+    examplesDir / "pos" / "capture" / "selfregion.effekt",
+    examplesDir / "benchmarks" / "other" / "generator.effekt",
+    examplesDir / "pos" / "bidirectional" / "typeparametric.effekt",
+    examplesDir / "benchmarks" / "are_we_fast_yet" / "permute.effekt",
+    examplesDir / "benchmarks" / "are_we_fast_yet" / "storage.effekt",
 
     // top-level object definition
     //examplesDir / "pos" / "object" / "if_control_effect.effekt",
@@ -65,18 +72,6 @@ class LLVMTests extends EffektTests {
     //examplesDir / "pos" / "bidirectional" / "higherorderobject.effekt",
     //examplesDir / "pos" / "bidirectional" / "res_obj_boxed.effekt",
     //examplesDir / "pos" / "bidirectional" / "effectfulobject.effekt",
-
-    // no block info
-    //examplesDir / "pos" / "capture" / "regions.effekt",
-    //examplesDir / "pos" / "capture" / "selfregion.effekt",
-    //examplesDir / "benchmarks" / "other" / "generator.effekt",
-
-    // hole
-    //examplesDir / "pos" / "bidirectional" / "typeparametric.effekt",
-
-    // segfault
-    //examplesDir / "benchmarks" / "are_we_fast_yet" / "permute.effekt",
-    //examplesDir / "benchmarks" / "are_we_fast_yet" / "storage.effekt",
   )
 
   override lazy val ignored: List[File] = missingFeatures ++ noValgrind(examplesDir)

effekt/jvm/src/test/scala/effekt/StdlibTests.scala

@@ -21,19 +21,16 @@ class StdlibJavaScriptTests extends StdlibTests {
 
   override def withoutOptimizations: List[File] = List(
     examplesDir / "stdlib" / "acme.effekt",
-
-    //examplesDir / "stdlib" / "json.effekt",
-    //examplesDir / "stdlib" / "exception" / "combinators.effekt",
-
-    // reference error (k is not defined)
-    //examplesDir / "stdlib" / "stream" / "fibonacci.effekt",
-    //examplesDir / "stdlib" / "list" / "flatmap.effekt",
-    //examplesDir / "stdlib" / "list" / "sortBy.effekt",
-    //examplesDir / "stdlib" / "stream" / "zip.effekt",
-    //examplesDir / "stdlib" / "stream" / "characters.effekt",
-
-    // oom
-    //examplesDir / "stdlib" / "list" / "deleteat.effekt",
+    examplesDir / "stdlib" / "json.effekt",
+    examplesDir / "stdlib" / "exception" / "combinators.effekt",
+    examplesDir / "stdlib" / "stream" / "fibonacci.effekt",
+    examplesDir / "stdlib" / "list" / "flatmap.effekt",
+    examplesDir / "stdlib" / "list" / "sortBy.effekt",
+    examplesDir / "stdlib" / "stream" / "zip.effekt",
+    examplesDir / "stdlib" / "stream" / "characters.effekt",
+    examplesDir / "stdlib" / "list" / "deleteat.effekt",
+    examplesDir / "stdlib" / "char" / "ascii_isalphanumeric.effekt",
+    examplesDir / "stdlib" / "char" / "ascii_iswhitespace.effekt",
   )
 
   override def ignored: List[File] = List()

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

@@ -10,7 +10,7 @@ import effekt.PhaseResult.CoreTransformed
  */
 trait CoreTests extends munit.FunSuite {
 
-  protected def defaultNames = symbols.builtins.rootTypes ++ symbols.builtins.rootTerms ++ symbols.builtins.rootCaptures
+  protected def defaultNames: Map[String, _root_.effekt.symbols.Symbol] = symbols.builtins.rootTypes ++ symbols.builtins.rootCaptures
 
   def shouldBeEqual(obtained: ModuleDecl, expected: ModuleDecl, clue: => Any)(using Location) =
     assertEquals(obtained, expected, {

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

@@ -357,8 +357,8 @@ class VMTests extends munit.FunSuite {
       poppedFrames = 8661,
       allocations = 0,
       closures = 0,
-      variableReads = 32437,
-      variableWrites = 13699,
+      variableReads = 23776,
+      variableWrites = 5039,
       resets = 0,
       shifts = 0,
       resumes = 0
@@ -373,8 +373,8 @@ class VMTests extends munit.FunSuite {
       poppedFrames = 5462,
       allocations = 5461,
       closures = 0,
-      variableReads = 13654,
-      variableWrites = 9557,
+      variableReads = 8192,
+      variableWrites = 4096,
       resets = 0,
       shifts = 0,
       resumes = 0

effekt/shared/src/main/scala/effekt/Typer.scala

@@ -54,21 +54,6 @@ object Typer extends Phase[NameResolved, Typechecked] {
         Context in {
           Context.withUnificationScope {
             flowingInto(builtins.toplevelCaptures) {
-              // bring builtins into scope
-              builtins.rootTerms.values.foreach {
-                case term: BlockParam =>
-                  Context.bind(term, term.tpe.getOrElse {
-                    INTERNAL_ERROR("Builtins should always be annotated with their types.")
-                  })
-                  Context.bind(term, CaptureSet(term.capture))
-                case term: ExternResource =>
-                  Context.bind(term, term.tpe)
-                  Context.bind(term, CaptureSet(term.capture))
-                case term: Callable =>
-                  Context.bind(term, term.toType)
-                case term => Context.panic(s"Cannot bind builtin term: ${term}")
-              }
-
               // We split the type-checking of definitions into "pre-check" and "check"
               // to allow mutually recursive defs
               tree.defs.foreach { d => precheckDef(d) }

effekt/shared/src/main/scala/effekt/core/vm/VM.scala

@@ -331,11 +331,6 @@ class Interpreter(instrumentation: Instrumentation, runtime: Runtime) {
         // TODO make the type of Region more precise...
         case Stmt.Region(_) => ???
 
-        case Stmt.Alloc(id, init, region, body) if region == symbols.builtins.globalRegion =>
-          val value = eval(init, env)
-          val address = freshAddress()
-          State.Step(body, env.bind(id, Computation.Reference(address)), stack, heap.updated(address, value))
-
         case Stmt.Alloc(id, init, region, body) =>
           val value = eval(init, env)
 

effekt/shared/src/main/scala/effekt/generator/chez/Transformer.scala

@@ -95,9 +95,6 @@ trait Transformer {
     case Var(ref, init, capt, body) =>
       state(nameDef(ref), toChez(init), toChez(body))
 
-    case Alloc(id, init, region, body) if region == symbols.builtins.globalRegion =>
-      chez.Let(List(Binding(nameDef(id), chez.Builtin("box", toChez(init)))), toChez(body))
-
     case Alloc(id, init, region, body) =>
       chez.Let(List(Binding(nameDef(id), chez.Builtin("fresh", chez.Variable(nameRef(region)), toChez(init)))), toChez(body))
 

effekt/shared/src/main/scala/effekt/generator/js/TransformerCps.scala

@@ -70,12 +70,7 @@ object TransformerCps extends Transformer {
         val jsDecls   = module.declarations.flatMap(toJS)
         val stmts     = module.definitions.map(toJS)
 
-        val state = js.Const(
-          nameDef(symbols.builtins.globalRegion),
-          js.Variable(JSName("global"))
-        ) :: Nil
-
-        js.Module(name, Nil, exports, jsDecls ++ jsExterns ++ state ++ stmts)
+        js.Module(name, Nil, exports, jsDecls ++ jsExterns ++ stmts)
     }
 
   def compileLSP(input: cps.ModuleDecl, coreModule: core.ModuleDecl)(using C: Context): List[js.Stmt] =

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

@@ -378,8 +378,6 @@ object Transformer {
 
   def transform(value: machine.Variable)(using FunctionContext): Operand =
     substitute(value) match {
-      // TODO rethink existence of global
-      case machine.Variable("global", machine.Type.Prompt()) => ConstantGlobal("global")
       case machine.Variable(name, tpe) => LocalReference(transform(tpe), name)
     }
 

effekt/shared/src/main/scala/effekt/machine/Transformer.scala

@@ -89,9 +89,7 @@ object Transformer {
 
           // Regions are blocks and can be free, but do not have info.
           case core.Variable.Block(id, core.Type.TRegion, capt) =>
-            if id == symbols.builtins.globalRegion
-            then Set.empty
-            else Set(Variable(transform(id), Type.Prompt()))
+            Set(Variable(transform(id), Type.Prompt()))
 
           case core.Variable.Block(pid, tpe, capt) if pid != id => BPC.info.get(pid) match {
               // For each known free block we have to add its free variables to this one (flat closure)
@@ -120,13 +118,16 @@ object Transformer {
         noteParameter(id, block.tpe)
         New(Variable(transform(id), transform(impl.interface)), transform(impl), transform(rest))
 
-      case core.Def(id, block @ core.BlockVar(alias, tpe, _), rest) =>
-        getDefinition(alias) match {
+      case core.Def(id, core.BlockVar(other, tpe, capt), rest) =>
+        getBlockInfo(other) match {
           case BlockInfo.Definition(free, params) =>
             noteDefinition(id, free, params)
+            emitDefinition(transformLabel(id), Jump(transformLabel(other)))
+            transform(rest)
+          case BlockInfo.Parameter(_) =>
+            noteParameter(id, tpe)
+            Substitute(List(Variable(transform(id), transform(tpe)) -> Variable(transform(other), transform(tpe))), transform(rest))
         }
-        emitDefinition(transformLabel(id), Jump(transformLabel(alias)))
-        transform(rest)
 
       case core.Def(id, block @ core.Unbox(pure), rest) =>
         noteParameter(id, block.tpe)
@@ -246,6 +247,8 @@ object Transformer {
         Resume(Variable(transform(k.id), Type.Stack()), transform(body))
 
       case core.Region(core.BlockLit(tparams, cparams, vparams, List(region), body)) =>
+        noteParameters(List(region))
+
         val variable = Variable(freshName("returned"), transform(body.tpe))
         val returnClause = Clause(List(variable), Return(List(variable)))
         val prompt = transform(region)
@@ -254,24 +257,13 @@ object Transformer {
 
       case core.Alloc(id, init, region, body) =>
         transform(init).run { value =>
-          val tpe = value.tpe;
-          val name = transform(id)
-          val variable = Variable(name, tpe)
-          val reference = Variable(transform(id), Type.Reference(tpe))
+          val reference = Variable(transform(id), Type.Reference(value.tpe))
           val prompt = Variable(transform(region), Type.Prompt())
           val temporary = Variable(freshName("temporaryStack"), Type.Stack())
 
-          region match {
-            case symbols.builtins.globalRegion =>
-              val globalPrompt = Variable("global", Type.Prompt())
-              Shift(temporary, globalPrompt,
-                Var(reference, value, Type.Positive(),
-                  Resume(temporary, transform(body))))
-            case _ =>
-              Shift(temporary, prompt,
-                Var(reference, value, Type.Positive(),
-                  Resume(temporary, transform(body))))
-          }
+          Shift(temporary, prompt,
+            Var(reference, value, Type.Positive(),
+              Resume(temporary, transform(body))))
         }
 
       case core.Var(ref, init, capture, body) =>
@@ -486,8 +478,9 @@ object Transformer {
     case core.BlockType.Interface(symbol, targs) => Negative()
   }
 
-  def transformLabel(id: Id)(using BPC: BlocksParamsContext): Label = getDefinition(id) match {
+  def transformLabel(id: Id)(using BPC: BlocksParamsContext): Label = getBlockInfo(id) match {
     case BlockInfo.Definition(freeParams, boundParams) => Label(transform(id), boundParams ++ freeParams)
+    case BlockInfo.Parameter(_) => sys error s"Expected a function definition, but got a block parameter: ${id}"
   }
 
   def transform(id: Id): String =
@@ -554,11 +547,6 @@ object Transformer {
   def getBlockInfo(id: Id)(using BPC: BlocksParamsContext): BlockInfo =
     BPC.info.getOrElse(id, sys error s"No block info for ${util.show(id)}")
 
-  def getDefinition(id: Id)(using BPC: BlocksParamsContext): BlockInfo.Definition = getBlockInfo(id) match {
-    case d : BlockInfo.Definition => d
-    case BlockInfo.Parameter(tpe) => sys error s"Expected a function getDefinition, but got a block parameter: ${id}"
-  }
-
   case class Binding[A](run: (A => Statement) => Statement) {
     def flatMap[B](rest: A => Binding[B]): Binding[B] = {
       Binding(k => run(a => rest(a).run(k)))

effekt/shared/src/main/scala/effekt/symbols/builtins.scala

@@ -53,6 +53,9 @@ object builtins {
   val AsyncSymbol = Interface(Name.local("Async"), Nil, Nil)
   val AsyncCapability = ExternResource(name("async"), InterfaceType(AsyncSymbol, Nil))
 
+  val GlobalSymbol = Interface(Name.local("Global"), Nil, Nil)
+  val GlobalCapability = ExternResource(name("global"), InterfaceType(GlobalSymbol, Nil))
+
   object TState {
     val S: TypeParam = TypeParam(Name.local("S"))
     val interface: Interface = Interface(Name.local("Ref"), List(S), Nil)
@@ -86,23 +89,16 @@ object builtins {
     "Region" -> RegionSymbol
   )
 
-  lazy val globalRegion = ExternResource(name("global"), TRegion)
-
-  val rootTerms: Map[String, TermSymbol] = Map(
-    "global" -> globalRegion
-  )
-
   val rootCaptures: Map[String, Capture] = Map(
     "io" -> IOCapability.capture,
     "async" -> AsyncCapability.capture,
-    "global" -> globalRegion.capture
+    "global" -> GlobalCapability.capture
   )
 
   // captures which are allowed on the toplevel
-  val toplevelCaptures: CaptureSet = CaptureSet() // CaptureSet(IOCapability.capture, globalRegion.capture)
+  val toplevelCaptures: CaptureSet = CaptureSet() // CaptureSet(IOCapability.capture, GlobalCapability.capture)
 
   lazy val rootBindings: Bindings =
-    Bindings(rootTerms.map { case (k, v) => (k, Set(v)) }, rootTypes, rootCaptures,
-      Map("effekt" -> Bindings(rootTerms.map { case (k, v) => (k, Set(v)) }, rootTypes, rootCaptures, Map.empty)))
+    Bindings(Map.empty, rootTypes, rootCaptures, Map("effekt" -> Bindings(Map.empty, rootTypes, rootCaptures, Map.empty)))
 
 }

examples/benchmarks/are_we_fast_yet/permute.effekt

@@ -1,5 +1,6 @@
 import examples/benchmarks/runner
 
+import ref
 import array
 
 def swap(arr: Array[Int], i: Int, j: Int) = {
@@ -9,10 +10,10 @@ def swap(arr: Array[Int], i: Int, j: Int) = {
 }
 
 def run(n: Int) = {
-  var count in global = 0;
+  val count = ref(0);
 
   def permute(arr: Array[Int], n: Int): Unit = {
-    count = count + 1;
+    count.set(count.get + 1);
     if (n != 0) {
       val n1 = n - 1;
       permute(arr, n1);
@@ -28,7 +29,7 @@ def run(n: Int) = {
 
   array(n, 1).permute(n);
 
-  count
+  count.get
 }
 
 def main() = benchmark(6){run}

examples/benchmarks/are_we_fast_yet/storage.effekt

@@ -1,5 +1,6 @@
 import examples/benchmarks/runner
 
+import ref
 import array
 
 type Tree {
@@ -25,10 +26,10 @@ def withRandom[R]{ program: { Random } => R }: R = {
 }
 
 def run(n: Int) = {
-  var count in global = 0;
+  val count = ref(0);
 
   def buildTreeDepth(depth: Int) { rand: Random }: Tree = {
-    count = count + 1;
+    count.set(count.get + 1);
     if (depth == 1) {
       Leaf(allocate(mod(rand.next, 10) + 1))
     } else {
@@ -44,7 +45,7 @@ def run(n: Int) = {
     withRandom { { rand: Random } => buildTreeDepth(7) {rand}; () }
   }
 
-  count
+  count.get
 }
 
 def main() = benchmark(1){run}

examples/pos/bidirectional/typeparametric.effekt

@@ -3,6 +3,7 @@ extern interface Cap[U, V]
 extern pure def cap[U, V](): Cap[U, V] at {} =
   js   "42"
   chez "42"
+  llvm "ret %Pos undef"
 
 interface Foo[S] {
   def op[A]() {f: Cap[S, A]}: Cap[S, A] at {f} / { Exception[S] }

examples/pos/capture/selfregion.effekt

@@ -46,8 +46,8 @@ def ex5() =
 
 
 def ex6() = {
-  var x in global = 42;
-  println(x + x)
+  val x = ref(42);
+  println(x.get + x.get)
 }
 
 def main() = {