Direct-style (DS) JS Backend

effekt/js/src/test/scala/effekt/WebTests.scala

@@ -40,7 +40,7 @@ object WebTests extends TestSuite {
     def evaluate[A](imports: List[String], content: String) = {
       server.writeFile("interactive.effekt", imports.map(i => s"import $i").mkString("\n") + s"\n\ndef main() = ${content}")
       val mainFile = server.compileFile("interactive.effekt")
-      load(mainFile.replace("out/", "")).main().run().asInstanceOf[A]
+      load(mainFile.replace("out/", "")).main().asInstanceOf[A]
     }
 
     test("Evaluate simple expressions in REPL") {

effekt/jvm/src/main/scala/effekt/Runner.scala

@@ -109,7 +109,7 @@ object JSRunner extends Runner[String] {
     val jsFilePath = (out / path).unixPath
     // create "executable" using shebang besides the .js file
     val jsScriptFilePath = jsFilePath.stripSuffix(s".$extension")
-    val jsScript = s"require('${jsFilePath}').main().run()"
+    val jsScript = s"require('${jsFilePath}').main()"
     val shebang = "#!/usr/bin/env node"
     IO.createFile(jsScriptFilePath, s"$shebang\n$jsScript", true)
     jsScriptFilePath
@@ -213,7 +213,7 @@ object MLRunner extends Runner[String] {
    * Requires the MLton compiler to be installed on the machine.
    * Assumes [[path]] has the format "SOMEPATH.sml".
    */
-  override def build(path: String)(using C: Context): String = 
+  override def build(path: String)(using C: Context): String =
     val out = C.config.outputPath()
     val buildFile = (out / "main.mlb").canonicalPath
     val executable = (out / "mlton-main").canonicalPath

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

@@ -25,6 +25,12 @@ class JavaScriptTests extends EffektTests {
     // we deprecated locally defined type and effect declarations, for now.
     examplesDir / "neg" / "existential_effect_leaks.effekt",
     examplesDir / "neg" / "scoped.effekt",
+
+    // Missing features in new direct style backend:
+    // ---------------------------------------------
+
+    // trampolining
+    examplesDir / "pos" / "stacksafe.effekt"
   )
 }
 

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

@@ -10,23 +10,40 @@ import effekt.PhaseResult.CoreTransformed
  */
 trait CoreTests extends munit.FunSuite {
 
-  protected val defaultNames = new Names(symbols.builtins.rootTypes ++ symbols.builtins.rootTerms ++ symbols.builtins.rootCaptures)
+  protected def defaultNames = symbols.builtins.rootTypes ++ symbols.builtins.rootTerms ++ symbols.builtins.rootCaptures
+
+  def shouldBeEqual(obtained: ModuleDecl, expected: ModuleDecl, clue: => Any)(using Location) =
+    assertEquals(obtained, expected, {
+      s"""${clue}
+        |=====================
+        |Got:
+        |----
+        |${effekt.core.PrettyPrinter.format(obtained).layout}
+        |
+        |Expected:
+        |---------
+        |${effekt.core.PrettyPrinter.format(expected).layout}
+        |
+        |""".stripMargin
+    })
 
   def assertAlphaEquivalent(obtained: ModuleDecl,
                             expected: ModuleDecl,
                             clue: => Any = "values are not alpha-equivalent",
-                            names: Names = defaultNames)(using Location): Unit = {
-    val renamer = Renamer(names)
-    assertEquals(renamer(obtained), renamer(expected), clue=clue)
+                            names: Names = Names(defaultNames))(using Location): Unit = {
+    val renamer = Renamer(names, "$")
+    shouldBeEqual(renamer(obtained), renamer(expected), clue)
   }
   def parse(input: String,
             nickname: String = "input",
-            names: Names = defaultNames): ModuleDecl = {
+            names: Names = Names(defaultNames))(using Location): ModuleDecl = {
     CoreParsers.module(input, names) match {
       case Success(result, next) if next.atEnd => result
       case Success(result, next) => fail(s"Parsing ${nickname} had trailing garbage: " +
         s"${next.source.toString.substring(next.offset)}")
-      case err: NoSuccess => fail(s"Parsing ${nickname} failed: ${err.message}")
+      case err: NoSuccess =>
+        val pos = err.next.position
+        fail(s"Parsing ${nickname} failed\n[${pos.line}:${pos.column}] ${err.message}")
     }
   }
 
@@ -38,7 +55,7 @@ trait CoreTransformationTests extends CoreTests {
 
   def assertTransformsTo(input: String, expected: String,
                          clue: => Any = "transformation result is not the expected one",
-                         names: Names = defaultNames)(using Location): Unit = {
+                         names: Names = Names(defaultNames))(using Location): Unit = {
     val pInput = parse(input, "input", names = names)
     val pExpected = parse(expected, "expected result", names = names)
     val obtained = transform(pInput)
@@ -68,4 +85,4 @@ trait CorePhaseTests[P <: Phase[CoreTransformed, CoreTransformed]](phase: P) ext
       }
     }
   }
-}
+}

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

@@ -0,0 +1,39 @@
+package effekt.core
+
+
+class LambdaLiftingTests extends CorePhaseTests(LambdaLifting) {
+
+  test("toplevel functions stay unchanged"){
+    val from =
+      """module main
+        |
+        |def id = { ['A](a: 'A) => return a: 'A }
+        |""".stripMargin
+    assertTransformsTo(from, from)
+  }
+
+  test("local functions are lifted out"){
+    val from =
+      """module main
+        |
+        |def outer = { () =>
+        |   def local = { () => return 42 }
+        |   val res = (local: () => Int @ {})();
+        |   return res:Int
+        |}
+        |""".stripMargin
+
+    val to =
+      """module main
+        |
+        |def outer = { () =>
+        |  val res = (local: () => Int @ {})();
+        |  return res:Int
+        |}
+        |
+        |def local = { () => return 42 }
+        |""".stripMargin
+    assertTransformsTo(from, to)
+  }
+
+}

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

@@ -36,11 +36,10 @@ abstract class AbstractPolymorphismBoxingTests extends CorePhaseTests(Polymorphi
     }
   }
 
-  override protected val defaultNames = new Names(boxtpes ++
+  override protected val defaultNames = boxtpes ++
     symbols.builtins.rootTypes ++ Map(
     // TODO maybe add used names
-  ))
-
+  )
 }
 class PolymorphismBoxingTests extends AbstractPolymorphismBoxingTests {
 

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

@@ -6,12 +6,12 @@ class RenamerTests extends CoreTests {
   def assertRenamedTo(input: String,
                       renamed: String,
                       clue: => Any = "Not renamed to given value",
-                      names: Names = defaultNames)(using munit.Location) = {
+                      names: Names = Names(defaultNames))(using munit.Location) = {
     val pInput = parse(input, "input", names)
     val pExpected = parse(renamed, "expected", names)
     val renamer = new Renamer(names, "renamed") // use "renamed" as prefix so we can refer to it
     val obtained = renamer(pInput)
-    assertEquals(obtained, pExpected, clue)
+    shouldBeEqual(obtained, pExpected, clue)
   }
 
   test("No bound local variables"){
@@ -100,12 +100,13 @@ class RenamerTests extends CoreTests {
           |type Data { X(a:Int, b:Int) }
           |def foo = { () =>
           |  12 match {
-          |    X : {(renamed2:Int, renamed1:Int) => return renamed2:Int }
+          |    X : {(renamed1:Int, renamed2:Int) => return renamed1:Int }
           |  }
           |}
           |""".stripMargin
     assertRenamedTo(input, expected)
   }
+
   test("type parameters"){
     val input =
       """module main
@@ -117,10 +118,60 @@ class RenamerTests extends CoreTests {
     val expected =
       """module main
         |
-        |def foo = { ['renamed2](renamed1: renamed2) =>
-        |  return renamed1:Identity[renamed2]
+        |def foo = { ['renamed1](renamed2: renamed1) =>
+        |  return renamed2:Identity[renamed1]
         |}
         |""".stripMargin
     assertRenamedTo(input, expected)
   }
+
+  test("pseudo recursive"){
+    val input =
+      """ module main
+        |
+        | def bar = { () => return 1 }
+        | def main = { () =>
+        |   def foo = { () => (bar : () => Unit @ {})() }
+        |   def bar = { () => return 2 }
+        |   (foo : () => Unit @ {})()
+        | }
+        |""".stripMargin
+
+    val expected =
+      """ module main
+        |
+        | def bar = { () => return 1 }
+        | def main = { () =>
+        |   def renamed1 = { () => (bar : () => Unit @ {})() }
+        |   def renamed2 = { () => return 2 }
+        |   (renamed1 : () => Unit @ {})()
+        | }
+        |""".stripMargin
+
+    assertRenamedTo(input, expected)
+  }
+  // TODO this needs to be fixed
+  //  test("shadowing let bindings"){
+  //    val input =
+  //      """ module main
+  //        |
+  //        | def main = { () =>
+  //        |   let x = 1
+  //        |   let x = 2
+  //        |   return x:Int
+  //        | }
+  //        |""".stripMargin
+  //
+  //    val expected =
+  //      """ module main
+  //        |
+  //        | def main = { () =>
+  //        |   let renamed1 = 1
+  //        |   let renamed2 = 2
+  //        |   return renamed2:Int
+  //        | }
+  //        |""".stripMargin
+  //
+  //    assertRenamedTo(input, expected)
+  //  }
 }

effekt/shared/src/main/scala/effekt/Compiler.scala

@@ -1,8 +1,8 @@
 package effekt
 
-import effekt.PhaseResult.{ CoreLifted, CoreTransformed }
+import effekt.PhaseResult.{ AllTransformed, CoreLifted, CoreTransformed }
 import effekt.context.Context
-import effekt.core.{ DirectStyleMutableState, Transformer, Optimizer }
+import effekt.core.{ DirectStyleMutableState, Transformer }
 import effekt.lifted.LiftInference
 import effekt.namer.Namer
 import effekt.source.{ AnnotateCaptures, ExplicitCapabilities, ModuleDecl }
@@ -236,6 +236,22 @@ trait Compiler[Executable] {
     Transformer
   }
 
+  /**
+   * Maps the phase over all core modules (dependencies and the main module)
+   */
+  def all(phase: Phase[CoreTransformed, CoreTransformed]): Phase[AllTransformed, AllTransformed] =
+    new Phase[AllTransformed, AllTransformed] {
+      val phaseName = s"all-${phase.phaseName}"
+
+      def run(input: AllTransformed)(using Context) = for {
+        main <- phase(input.main)
+        dependencies <- input.dependencies.foldRight[Option[List[CoreTransformed]]](Some(Nil)) {
+          case (dep, Some(deps)) => phase(dep).map(_ :: deps)
+          case (_, _) => None
+        }
+      } yield AllTransformed(input.source, main, dependencies)
+    }
+
   def allToCore(phase: Phase[Source, CoreTransformed]): Phase[Source, AllTransformed] = new Phase[Source, AllTransformed] {
     val phaseName = "core-dependencies"
 

effekt/shared/src/main/scala/effekt/context/Annotations.scala

@@ -29,7 +29,7 @@ class Annotations private(
 
   def copy: Annotations = new Annotations(annotations)
 
-  private def annotationsAt[K, V](ann: Annotation[K, V]): Map[Key[K], V] =
+  def annotationsAt[K, V](ann: Annotation[K, V]): Map[Key[K], V] =
     annotations.getOrElse(ann, Map.empty).asInstanceOf
 
   def update[K, V](ann: Annotation[K, V], key: K, value: V): Unit = {
@@ -90,6 +90,10 @@ object Annotations {
     }
   }
 
+  object Key {
+    def unapply[T](k: Key[T]): Option[T] = Some(k.key)
+  }
+
   private def makeKey[K, V](ann: Annotation[K, V], k: K): Key[K] =
     if (ann.bindToObjectIdentity) new HashKey(k)
     else new IdKey(k)