Fix: Make case studies runnable on the website (#1009)

Currently, the case studies are not runnable on the website or resort to
the trick of having an empty REPL where you have to input `main()`. In
this PR, I try to properly handle `effekt:repl` in literate Effekt files
such that it has the same (observable) behaviour as on the website.
Since expressions can not be top-level, I wrap them in a function `def
replN() = <REPL-CONTENT>` and later append a main function where all
repl cells are called:

```
def repl1() = 1 + 2
def repl2() = println("hello")

def main() = {
  inspect(repl1())
  inspect(repl2())
  ()
}
```

If there's already a user-defined `main` function, then an error occurs.
Though, I argue that the user should not define a `main` function in a
literate Effekt file, as this kind of defeats its purpose.

Furthermore, I also tackle the issue of importing non-stdlib modules by
just merging all files in the dependency chain into the same file and
adding appropriate redirects for the old links.

Changes:

- You may now either have one or more `effekt:repl` code fences or one manually defined `main` function
- A repl cell is translated such that it is wrapped in a function:
  ```
  def replN = {
    stmt
  }
  ```
  corresponds to
  ````
  ```effekt:repl
  stmt
  ```
  ````
  where `def replN = {` is inserted for the opening fence and `}` for the closing fence to preserve positional information.
- You may now have other languages in a literate effekt file other than Effekt, e.g. ```` ```scala ```` gives you syntax highlighting but is ignored by the effekt compiler
- Similarly, `effekt:ignore` code fences are also ignored by the compiler
- Previously, `[[()]] = #f` in chez. Now, `[[()]] = #<void>`, reasone being that `inspect(inspect(())) = inspect(())` should hold but with `[[()]] = #f` it is not since `inspect` returns `#<void>`.
- `anf`, `lexer`, `pretty` and `parser` are concatenated into a single file to solve import issues.

---------

Co-authored-by: Jiří Beneš <[email protected]>

Author: dvdvgt

effekt/jvm/src/test/scala/effekt/ChezSchemeTests.scala

@@ -9,18 +9,20 @@ import scala.language.implicitConversions
 
 abstract class ChezSchemeTests extends EffektTests {
 
-  override def positives: List[File] = List(
+  override def positives: Set[File] = Set(
     examplesDir / "pos",
     examplesDir / "casestudies",
     examplesDir / "chez",
     examplesDir / "benchmarks"
   )
 
   // Test files which are to be ignored (since features are missing or known bugs exist)
-  override def ignored: List[File] = List(
+  override def ignored: Set[File] = super.ignored ++ Set(
 
     examplesDir / "llvm",
 
+    examplesDir / "casestudies" / "smc.effekt.md",
+
     // bidirectional effects are not yet supported in our Chez backend
     examplesDir / "pos" / "maps.effekt",
     examplesDir / "pos" / "bidirectional",
@@ -49,6 +51,7 @@ abstract class ChezSchemeTests extends EffektTests {
     // in the CallCC variant, we cannot have toplevel vals at the moment (their bindings need to be wrapped in `(run (thunk ...))`
     // see comment on commit 61492d9
     examplesDir / "casestudies" / "anf.effekt.md",
+    examplesDir / "casestudies" / "frontend.effekt.md",
 
     // we do not need to run the negative tests for the other backends
     examplesDir / "neg",

effekt/jvm/src/test/scala/effekt/EffektTests.scala

@@ -29,15 +29,17 @@ trait EffektTests extends munit.FunSuite {
   def examplesDir = new File("examples")
 
   // Test files which are to be ignored (since features are missing or known bugs exist)
-  def ignored: List[File] = List()
+  def ignored: Set[File] = Set(
+    examplesDir / "casestudies" / "smc.effekt.md"
+  )
 
   // Folders to discover and run tests in
-  def positives: List[File] = List()
+  def positives: Set[File] = Set()
 
-  def negatives: List[File] = List()
+  def negatives: Set[File] = Set()
 
   // Test files that should be run with optimizations disabled
-  def withoutOptimizations: List[File] = List()
+  def withoutOptimizations: Set[File] = Set()
 
   def runTestFor(input: File, expected: String): Unit =
     test(input.getPath + s" (${backendName})") {

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

@@ -14,17 +14,17 @@ class JavaScriptTests extends EffektTests {
 
   def backendName = "js"
 
-  override def positives: List[File] = List(
+  override def positives: Set[File] = Set(
     examplesDir / "pos",
     examplesDir / "casestudies",
     examplesDir / "benchmarks",
   )
 
-  override def negatives: List[File] = List(
+  override def negatives: Set[File] = Set(
     examplesDir / "neg"
   )
 
-  override lazy val withoutOptimizations: List[File] = List(
+  override lazy val withoutOptimizations: Set[File] = Set(
     // contifying under reset
     examplesDir / "pos" / "issue842.effekt",
     examplesDir / "pos" / "issue861.effekt",
@@ -34,9 +34,11 @@ class JavaScriptTests extends EffektTests {
     examplesDir / "pos" / "probabilistic.effekt",
   )
 
-  override def ignored: List[File] = List(
+  override def ignored: Set[File] = super.ignored ++ Set(
     // unsafe cont
-    examplesDir / "pos" / "propagators.effekt"
+    examplesDir / "pos" / "propagators.effekt",
+
+    examplesDir / "casestudies" / "smc.effekt.md"
   )
 }
 

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

@@ -13,7 +13,7 @@ class LLVMTests extends EffektTests {
   override def valgrind = sys.env.get("EFFEKT_VALGRIND").nonEmpty
   override def debug = sys.env.get("EFFEKT_DEBUG").nonEmpty
 
-  override lazy val positives: List[File] = List(
+  override lazy val positives: Set[File] = Set(
     examplesDir / "llvm",
     examplesDir / "pos",
     examplesDir / "benchmarks",
@@ -23,7 +23,7 @@ class LLVMTests extends EffektTests {
    * Documentation of currently failing tests because of missing features
    * and their reason
    */
-  lazy val missingFeatures: List[File] = List(
+  lazy val missingFeatures: Set[File] = Set(
     // Regex
     examplesDir / "pos" / "simpleparser.effekt",
 
@@ -33,6 +33,9 @@ class LLVMTests extends EffektTests {
     // unsafe cont
     examplesDir / "pos" / "propagators.effekt",
 
+    // no generic inspect
+    examplesDir / "casestudies",
+
     // Only JS (tests should be moved to a JS folder)
     examplesDir / "pos" / "genericcompare.effekt",
     examplesDir / "pos" / "multiline_extern_definition.effekt",
@@ -53,7 +56,7 @@ class LLVMTests extends EffektTests {
     examplesDir / "pos" / "issue733.effekt",
   )
 
-  override lazy val withoutOptimizations: List[File] = List(
+  override lazy val withoutOptimizations: Set[File] = Set(
     // contifying under reset
     examplesDir / "pos" / "issue842.effekt",
     examplesDir / "pos" / "issue861.effekt",
@@ -74,14 +77,14 @@ class LLVMTests extends EffektTests {
     examplesDir / "pos" / "bidirectional" / "effectfulobject.effekt",
   )
 
-  override lazy val ignored: List[File] = missingFeatures ++ noValgrind(examplesDir)
+  override lazy val ignored: Set[File] = missingFeatures ++ noValgrind(examplesDir) ++ super.ignored
 }
 
 /**
  * Documentation of tests that succeed in running, but fail valgrind
  * and their reason
  */
-def noValgrind(examplesDir: File): List[File] = List(
+def noValgrind(examplesDir: File): Set[File] = Set(
   examplesDir / "llvm" / "prompt-duplication.effekt",
 )
 
@@ -91,5 +94,5 @@ class LLVMNoValgrindTests extends EffektTests {
   override def valgrind = false
   override def debug = false
 
-  override lazy val positives: List[File] = noValgrind(examplesDir)
+  override lazy val positives: Set[File] = noValgrind(examplesDir)
 }

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

@@ -7,19 +7,19 @@ import sbt.io.syntax.*
 import scala.language.implicitConversions
 
 abstract class StdlibTests extends EffektTests {
-  override def positives: List[File] = List(
+  override def positives: Set[File] = Set(
     examplesDir / "stdlib",
   )
 
-  override def ignored: List[File] = List()
+  override def ignored: Set[File] = Set()
 
-  override def withoutOptimizations: List[File] = List()
+  override def withoutOptimizations: Set[File] = Set()
 }
 
 class StdlibJavaScriptTests extends StdlibTests {
   def backendName: String = "js"
 
-  override def withoutOptimizations: List[File] = List(
+  override def withoutOptimizations: Set[File] = Set(
     examplesDir / "stdlib" / "acme.effekt",
     examplesDir / "stdlib" / "json.effekt",
     examplesDir / "stdlib" / "exception" / "combinators.effekt",
@@ -33,11 +33,11 @@ class StdlibJavaScriptTests extends StdlibTests {
     examplesDir / "stdlib" / "char" / "ascii_iswhitespace.effekt",
   )
 
-  override def ignored: List[File] = List()
+  override def ignored: Set[File] = Set()
 }
 
 abstract class StdlibChezTests extends StdlibTests {
-  override def ignored: List[File] = List(
+  override def ignored: Set[File] = Set(
     // Not implemented yet
     examplesDir / "stdlib" / "io",
     examplesDir / "stdlib" / "stream" / "characters.effekt",
@@ -56,11 +56,11 @@ class StdlibLLVMTests extends StdlibTests {
   override def valgrind = sys.env.get("EFFEKT_VALGRIND").nonEmpty
   override def debug = sys.env.get("EFFEKT_DEBUG").nonEmpty
 
-  override def withoutOptimizations: List[File] = List(
+  override def withoutOptimizations: Set[File] = Set(
     examplesDir / "stdlib" / "acme.effekt",
   )
 
-  override def ignored: List[File] = List(
+  override def ignored: Set[File] = Set(
     // String comparison using `<`, `<=`, `>`, `>=` is not implemented yet on LLVM
     examplesDir / "stdlib" / "string" / "compare.effekt",
 

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

@@ -647,8 +647,8 @@ class VMTests extends munit.FunSuite {
       dynamicDispatches = 57,
       patternMatches = 31,
       branches = 40,
-      pushedFrames = 23,
-      poppedFrames = 20,
+      pushedFrames = 24,
+      poppedFrames = 21,
       allocations = 15,
       closures = 36,
       variableReads = 7,
@@ -663,8 +663,8 @@ class VMTests extends munit.FunSuite {
       dynamicDispatches = 7,
       patternMatches = 80,
       branches = 41,
-      pushedFrames = 56,
-      poppedFrames = 57,
+      pushedFrames = 57,
+      poppedFrames = 58,
       allocations = 58,
       closures = 7,
       variableReads = 29,
@@ -679,8 +679,8 @@ class VMTests extends munit.FunSuite {
       dynamicDispatches = 18,
       patternMatches = 205,
       branches = 405,
-      pushedFrames = 194,
-      poppedFrames = 194,
+      pushedFrames = 195,
+      poppedFrames = 195,
       allocations = 109,
       closures = 27,
       variableReads = 164,
@@ -723,19 +723,19 @@ class VMTests extends munit.FunSuite {
     )),
 
     examplesDir / "casestudies" / "inference.effekt.md" -> Some(Summary(
-      staticDispatches = 1457454,
-      dynamicDispatches = 3201452,
-      patternMatches = 1474254,
-      branches = 303298,
-      pushedFrames = 2914407,
-      poppedFrames = 2049112,
-      allocations = 4625971,
-      closures = 865541,
-      variableReads = 2908620,
-      variableWrites = 1453663,
-      resets = 288559,
-      shifts = 297723,
-      resumes = 9275
+      staticDispatches = 1482058,
+      dynamicDispatches = 3224955,
+      patternMatches = 1497935,
+      branches = 304502,
+      pushedFrames = 2943014,
+      poppedFrames = 2077323,
+      allocations = 4654126,
+      closures = 867068,
+      variableReads = 2955965,
+      variableWrites = 1480868,
+      resets = 288904,
+      shifts = 298107,
+      resumes = 9263
     )),
 
     examplesDir / "pos" / "raytracer.effekt" -> Some(Summary(

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

@@ -210,7 +210,7 @@ trait Transformer {
   }
 
   def toChez(expr: Expr): chez.Expr = expr match {
-    case Literal((), _)         => chez.RawValue("#f")
+    case Literal((), _)         => chez.RawValue("(void)")
 
     case Literal(s: String, _)  => escape(s)
     case Literal(b: Boolean, _) => if (b) chez.RawValue("#t") else chez.RawValue("#f")

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

@@ -1,6 +1,8 @@
 package effekt
 package util
 
+import scala.collection.mutable.ListBuffer
+
 import effekt.source.ModuleDecl
 
 import kiama.util.Source
@@ -10,28 +12,97 @@ import kiama.util.Source
  */
 case class MarkdownSource(source: Source) extends Source {
 
-  val fenceLine = """^```\s*(effekt)?\s*((\s|:)[^`]*)?$""".r
-  val otherFenceLine = """^```[^`\n]*$""".r
+  val fenceLine = """^```\s*(\w+)?\s*((?::[^:\n]*)*)$""".r
+  val emptyFence = """^```\s*$""".r
+
+  enum FenceType {
+    case Repl
+    case Ignore
+    case Code
+    case Other
+  }
 
   def name = source.name
 
   lazy val content = {
-    var inCode = false
-    var inOtherFence = false
+    import FenceType.*
+    var code = ListBuffer.empty[String]
+    var replCounter = 0
+    val lines = ListBuffer.empty[String]
+    var fenceType: Option[FenceType] = None
     // we map non-code lines to empty lines to preserve line numbers
-    val lines = source.content.linesIterator.map {
-      case line if fenceLine.matches(line) && !inOtherFence =>
-        inCode = !inCode
-        ""
-      case line if otherFenceLine.matches(line) =>
-        inOtherFence = !inOtherFence
-        ""
-      case line if inCode =>
-        line
-      case _ =>
-        ""
+    source.content.linesIterator.foreach { 
+      case fenceLine(lang, ots) =>
+        val opts = if (ots != null) { ots.tail.split(":").toList } else { Nil }
+        if (opts.contains("ignore")) {
+          fenceType = Some(Ignore)
+          lines += ""
+        } else if (opts.contains("repl")) {
+          fenceType = Some(Repl)
+          // opening fences are replaced by a wrapper function
+          lines += s"def repl${replCounter}() = {"
+          replCounter += 1
+        } else {
+          fenceType match {
+            // opening fences
+            case None =>
+              // ```effekt
+              if (lang != null && lang == "effekt") {
+                fenceType = Some(Code)
+              // ```scala
+              } else if (lang != null) {
+                fenceType = Some(Other)
+              // ```
+              } else {
+                fenceType = Some(Code)
+              }
+              lines += ""
+            // closing fences
+            case Some(fence) =>
+              fence match {
+                // closing fence of ```effekt:repl
+                case Repl =>
+                  // take care when wrapping to preserve line numbers
+                  lines ++= code
+                  // remember to close wrapper function
+                  lines += "}"
+                // closing fence of ```effekt or ```
+                case Code =>
+                  lines ++= code
+                  lines += ""
+                // closing fence of ```effekt:ignore
+                case Ignore =>
+                  lines += ""
+                // closing fence of ```scala or other languages
+                // same semantic as effekt:ignore
+                case Other =>
+                  lines += ""
+              }
+              fenceType = None
+              code = ListBuffer.empty
+          }
+        }
+      // collect code if in code fence
+      case line if fenceType.isDefined && line != "" =>
+        code += line
+      // add empty lines to preserve positional information outside of code fences
+      case line =>
+        lines += ""
+    }
+    val prog = lines.mkString("\n")
+    val repls = 0.until(replCounter).map { i => s"inspect(repl${i}())"}
+    // We either allow to have one manually defined main function XOR one or more REPLs
+    val main = if (replCounter > 0) {
+      s"""
+      |def main() = {
+      |${repls.mkString("\n") }
+      |()
+      |}
+      """.stripMargin
+    } else {
+      ""
     }
-    lines.mkString("\n")
+    prog ++ main
   }
 }