Direct-style (DS) JS Backend

effekt/js/src/main/scala/effekt/LanguageServer.scala

@@ -1,7 +1,7 @@
 package effekt
 
 import effekt.context.{ Context, VirtualFileSource, VirtualModuleDB }
-import effekt.generator.js.Transformer
+import effekt.generator.js.TransformerMonadic
 import effekt.lifted.LiftInference
 import effekt.util.{ PlainMessaging, getOrElseAborting }
 import effekt.util.messages.{ BufferedMessaging, EffektError, EffektMessaging, FatalPhaseError }
@@ -190,7 +190,7 @@ class LanguageServer extends Intelligence {
   }
 
   private def path(m: symbols.Module)(using C: Context): String =
-    (C.config.outputPath() / Transformer.jsModuleFile(m.path)).unixPath
+    (C.config.outputPath() / TransformerMonadic.jsModuleFile(m.path)).unixPath
 }
 
 @JSExportTopLevel("effekt")

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/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/OptimizerTests.scala

@@ -0,0 +1,222 @@
+package effekt
+package core
+import effekt.symbols
+
+class OptimizerTests extends CoreTests {
+
+  val mainSymbol = Id("main")
+
+  def assertTransformsTo(
+    input: String,
+    transformed: String,
+    names: Names = Names(defaultNames + ("main" -> mainSymbol))
+  )(transform: ModuleDecl => ModuleDecl)(using munit.Location) = {
+    val moduleHeader =
+      """module test
+        |
+        |""".stripMargin
+    val pInput = parse(moduleHeader + input, "input", names)
+    val pExpected = parse(moduleHeader + transformed, "expected", names)
+
+    // the parser is not assigning symbols correctly, so we need to run renamer first
+    val renamed = Renamer(names).rewrite(pInput)
+
+    val obtained = transform(renamed)
+    assertAlphaEquivalent(obtained, pExpected, "Not transformed to")
+  }
+
+  def removeUnused(input: String, expected: String)(using munit.Location) =
+    assertTransformsTo(input, expected) { tree =>
+      RemoveUnusedDefinitions.remove(Set(mainSymbol), tree)
+    }
+
+  def inlineOnce(input: String, expected: String)(using munit.Location) =
+    assertTransformsTo(input, expected) { tree =>
+      val (result, count) = InlineUnique.once(Set(mainSymbol), tree)
+      result
+    }
+
+  def inlineFull(input: String, expected: String)(using munit.Location) =
+    assertTransformsTo(input, expected) { tree =>
+      InlineUnique.full(Set(mainSymbol), tree)
+    }
+
+  test("toplevel"){
+    val input =
+      """ def foo = { () => return 42 }
+        | def main = { () => return 42 }
+        |""".stripMargin
+
+    val expected =
+      """ def main = { () => return 42 }
+        |""".stripMargin
+
+    removeUnused(input, expected)
+  }
+
+  test("transitive (length 3)"){
+    val input =
+      """ def foo = { () => return 42 }
+        | def bar = { () => (foo : () => Unit @ {})() }
+        | def baz = { () => (bar : () => Unit @ {})() }
+        | def bam = { () => (baz : () => Unit @ {})() }
+        | def main = { () => (bam : () => Unit @ {})() }
+        |""".stripMargin
+
+    removeUnused(input, input)
+  }
+
+  test("recursive (unused)"){
+    val input =
+      """ def foo = { () => (bar : () => Unit @ {})() }
+        | def bar = { () => (foo : () => Unit @ {})() }
+        | def main = { () => return 42 }
+        |""".stripMargin
+
+    val expected =
+      """ def main = { () => return 42 }
+        |""".stripMargin
+
+    removeUnused(input, expected)
+  }
+
+  test("recursive used"){
+    val input =
+      """ def foo = { () => (bar : () => Unit @ {})() }
+        | def bar = { () => (foo : () => Unit @ {})() }
+        | def main = { () => (foo : () => Unit @ {})() }
+        |""".stripMargin
+
+    removeUnused(input, input)
+  }
+
+  test("nested all removed"){
+    val input =
+      """ def main = { () =>
+        |   def foo = { () => return 1 }
+        |   return 2
+        | }
+        |""".stripMargin
+
+    val expected =
+      """ def main = { () => return 2 }
+        |""".stripMargin
+
+    removeUnused(input, expected)
+  }
+  // let y = !(println: (String) => Unit @ {io})("hello")
+  test("drop pure let expressions"){
+    val input =
+      """ def main = { () =>
+        |   let x = (add : (Int, Int) => Int @ {})(1, 2)
+        |   let y = !(println: (String) => Unit @ {io})("hello")
+        |   let z = 7
+        |   return z:Int
+        | }
+        |""".stripMargin
+
+    val expected =
+      """ def main = { () =>
+        |   let y = !(println: (String) => Unit @ {io})("hello")
+        |   let z = 7
+        |   return z:Int
+        | }
+        |""".stripMargin
+
+    removeUnused(input, expected)
+  }
+
+  test("pseudo recursive"){
+    val input =
+      """ def bar = { () => return 1 }
+        | def main = { () =>
+        |   def foo = { () => (bar : () => Unit @ {})() }
+        |   def bar = { () => return 2 }
+        |   (foo : () => Unit @ {})()
+        | }
+        |""".stripMargin
+
+
+    val expected =
+      """ def bar = { () => return 1 }
+        | def main = { () =>
+        |   def foo = { () => (bar : () => Unit @ {})() }
+        |   (foo : () => Unit @ {})()
+        | }
+        |""".stripMargin
+
+    removeUnused(input, expected)
+  }
+
+  test("inline toplevel"){
+    val input =
+      """ def foo = { () => return 42 }
+        | def main = { () => (foo : () => Unit @ {})() }
+        |""".stripMargin
+
+    val expected =
+      """ def foo = { () => return 42 }
+        | def main = { () => return 42 }
+        |""".stripMargin
+
+    inlineOnce(input, expected)
+  }
+
+  test("inline with argument"){
+    val input =
+      """ def foo = { (n: Int) => return n:Int }
+        | def main = { () => (foo : (Int) => Unit @ {})(42) }
+        |""".stripMargin
+
+    val expected =
+      """ def foo = { (n: Int) => return n:Int }
+        | def main = { () => return 42 }
+        |""".stripMargin
+
+    inlineOnce(input, expected)
+  }
+
+  test("inline higher order function"){
+    val input =
+      """ def foo = { (n: Int) => return n:Int }
+        | def hof = { (){f : (Int) => Int} =>
+        |   (f : (Int) => Int @ {f})(1)
+        | }
+        | def main = { () =>
+        |   (hof : (){f : (Int) => Int} => Int @ {})(){ (foo : (Int) => Unit @ {}) }
+        | }
+        |""".stripMargin
+
+    val expected =
+      """ def foo = { (n: Int) => return n:Int }
+        | def hof = { (){f : (Int) => Int} =>
+        |   (f : (Int) => Int @ {f})(1)
+        | }
+        | def main = { () =>
+        |   def local(n: Int) = return n:Int
+        |   (local : (Int) => Int @ {})(1)
+        | }
+        |""".stripMargin
+
+    inlineOnce(input, expected)
+  }
+
+  test("fully inline higher order function"){
+    val input =
+      """ def foo = { (n: Int) => return n:Int }
+        | def hof = { (){f : (Int) => Int} =>
+        |   (f : (Int) => Int @ {f})(1)
+        | }
+        | def main = { () =>
+        |   (hof : (){f : (Int) => Int} => Int @ {})(){ (foo : (Int) => Unit @ {}) }
+        | }
+        |""".stripMargin
+
+    val expected =
+      """ def main = { () => return 1 }
+        |""".stripMargin
+
+    inlineFull(input, expected)
+  }
+
+}

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 {