Add debug flag and separate type checking and inference (#1394)

In sbt you can now call
```
debug
```
to trigger the debug mode
and
```
release
```
to trigger the release mode.

`effekt.util.Debug` contains a few debugging helpers that are disabled
during release:

```scala
inline def debug(inline f: => Unit): Unit =
  inline if DEBUG then f else ()

inline def debug[T](inline f: => T)(inline otherwise: => T): T =
  inline if DEBUG then f else otherwise

inline def assert(inline assertion: Boolean): Unit =
  inline if DEBUG then Predef.assert(assertion)

inline def assert(inline assertion: Boolean, inline msg: => String): Unit =
  inline if DEBUG then Predef.assert(assertion, msg)
```

Author: b-studios

build.sbt

@@ -18,6 +18,7 @@ lazy val testBackendJS = taskKey[Unit]("Run JavaScript backend tests")
 lazy val testBackendChez = taskKey[Unit]("Run Chez Scheme backend tests")
 lazy val testBackendLLVM = taskKey[Unit]("Run LLVM backend tests")
 lazy val testRemaining = taskKey[Unit]("Run all non-backend tests (internal tests) on effektJVM")
+lazy val debugCompiler = settingKey[Boolean]("Enable compiler debugging")
 
 lazy val noPublishSettings = Seq(
   publish := {},
@@ -84,7 +85,9 @@ lazy val root = project.in(file("effekt"))
 lazy val effekt: CrossProject = crossProject(JSPlatform, JVMPlatform).in(file("effekt"))
   .settings(
     name := "effekt",
-    version := effektVersion
+    version := effektVersion,
+    debugCompiler := sys.props.get("debug").contains("true"),
+    Compile / sourceGenerators += versionGenerator.taskValue
   )
   .settings(commonSettings)
   .dependsOn(kiama)
@@ -144,6 +147,9 @@ lazy val effekt: CrossProject = crossProject(JSPlatform, JVMPlatform).in(file("e
     // cli flag so sbt doesn't crash when effekt does
     addCommandAlias("run", "runMain effekt.Main --no-exit-on-error"),
 
+    addCommandAlias("debug", ";set debugCompiler := true ;compile"),
+    addCommandAlias("release", ";set debugCompiler := false ;compile"),
+
     assembleBinary := {
       val jarfile = assembly.value
 
@@ -264,7 +270,6 @@ lazy val effekt: CrossProject = crossProject(JSPlatform, JVMPlatform).in(file("e
 
 
     generateDocumentation := TreeDocs.replacer.value,
-    Compile / sourceGenerators += versionGenerator.taskValue,
     Compile / sourceGenerators += TreeDocs.generator.taskValue,
 
     collectBenchmarks := benchmarks.collect.value,
@@ -308,16 +313,17 @@ lazy val mvn = Def.task {
   if (platform.value == "windows") "mvn.cmd" else "mvn"
 }
 
-
 lazy val versionGenerator = Def.task {
   val sourceDir = (Compile / sourceManaged).value
   val sourceFile = sourceDir / "effekt" / "util" / "Version.scala"
+  val debug = debugCompiler.value
 
   IO.write(sourceFile,
     s"""package effekt.util
        |
        |object Version {
        |  val effektVersion = \"${effektVersion}\"
+       |  inline val DEBUG = $debug
        |}
        |""".stripMargin)
 

effekt/jvm/src/main/scala/effekt/Main.scala

@@ -3,6 +3,7 @@ package effekt
 import org.rogach.scallop.exceptions.ScallopException
 
 object Main {
+
   /**
    * Main entry point for the Effekt compiler.
    *

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

@@ -37,7 +37,7 @@ class OptimizerTests extends CoreTests {
   def normalize(input: String, expected: String)(using munit.Location) =
     assertTransformsTo(input, expected) { tree =>
       val anfed = BindSubexpressions.transform(tree)
-      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, 50, true)
+      val normalized = Normalizer.normalize(Set(mainSymbol), anfed, 50)
       Deadcode.remove(mainSymbol, normalized)
     }
 

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

@@ -8,7 +8,7 @@ class SizeTests extends CoreTests {
   }
 
   test("Small program"){
-    assertSized(6) {
+    assertSized(4) {
       """module main
         |
         |def foo = { () =>
@@ -19,7 +19,7 @@ class SizeTests extends CoreTests {
   }
 
   test("Nested definitions") {
-    assertSized(15) {
+    assertSized(14) {
       """ module main
         |
         | def bar = { () => return 1 }

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

@@ -3,7 +3,7 @@ package core
 
 import effekt.core.Type.*
 import effekt.util.messages.{ DebugMessaging, ErrorReporter }
-import scala.collection.immutable.HashMap
+import effekt.util.DB
 
 class TypeInferenceTests extends CoreTests {
 
@@ -87,13 +87,13 @@ class TypeInferenceTests extends CoreTests {
   }
 
   test("compatibility") {
-    Free.mergeValues(HashMap.empty, HashMap.empty)
-    Free.mergeValues(HashMap(f -> TInt), HashMap.empty)
-    Free.mergeValues(HashMap(f -> TInt), HashMap(f -> TInt))
-    Free.mergeValues(HashMap(f -> TInt), HashMap(f -> TInt, g -> TByte))
+    Free.mergeValues(DB.empty, DB.empty)
+    Free.mergeValues(DB(f -> TInt), DB.empty)
+    Free.mergeValues(DB(f -> TInt), DB(f -> TInt))
+    Free.mergeValues(DB(f -> TInt), DB(f -> TInt, g -> TByte))
 
     intercept[TypeError] {
-      Free.mergeValues(HashMap(f -> TInt), HashMap(f -> TBoolean, g -> TByte))
+      Free.mergeValues(DB(f -> TInt), DB(f -> TBoolean, g -> TByte))
     }
   }
 
@@ -113,15 +113,12 @@ class TypeInferenceTests extends CoreTests {
     assertEquals(ex1.capt, Set.empty)
     assertEquals(ex1.free, Free.value(x, TInt).withoutValue(x, TInt))
 
-    intercept[TypeError] {
-      Stmt.Val(x,
-        Stmt.Return(Expr.Literal(true, TBoolean)),
-        Stmt.Return(Expr.ValueVar(x, TInt))).free.wellformed()
-    }
-
     // we can even type check open terms:
-    assertEquals(typecheck(Stmt.Return(Expr.ValueVar(x, TInt))),
-      Typing(TInt, Set.empty, Free.value(x, TInt)))
+    val ex2 = Stmt.Return(Expr.ValueVar(x, TInt))
+    assertEquals(typecheck(ex2),
+      Typing(TInt, Set.empty, Constraints.empty))
+
+    assertEquals(ex2.free, Free.value(x, TInt))
 
     val add: Block.BlockVar = Block.BlockVar(infixPlus, BlockType.Function(Nil, Nil, List(TInt, TInt), Nil, TInt), Set.empty)
 
@@ -132,8 +129,7 @@ class TypeInferenceTests extends CoreTests {
     val result3 = typecheck(ex3)
     assertEquals(result3.tpe, TInt)
     assertEquals(result3.capt, Set.empty)
-    assert(result3.free.freeIds == Set(add.id))
-    result3.free.wellformed()
+    assert(ex3.free.freeIds == Set(add.id))
 
     // [A](Option[A], A): A
     val orElse: Block.BlockVar = Block.BlockVar(f, BlockType.Function(A :: Nil, Nil, List(OptionT(ValueType.Var(A)), ValueType.Var(A)), Nil, ValueType.Var(A)), Set.empty)
@@ -143,26 +139,21 @@ class TypeInferenceTests extends CoreTests {
     // swapped arguments
     intercept[TypeError] {
       val res = typecheck(Expr.PureApp(orElse, TInt :: Nil, Expr.ValueVar(y, TInt) :: Expr.ValueVar(x, OptionT(TInt)) :: Nil))
-      res.free.wellformed()
+      res.check()
     }
     // too few arguments
     intercept[TypeError] {
       val res = typecheck(Expr.PureApp(orElse, TInt :: Nil, Expr.ValueVar(x, OptionT(TInt)) :: Nil))
-      res.free.wellformed()
-    }
-    // incompatible free variables in arguments
-    intercept[TypeError] {
-      val res = typecheck(Expr.PureApp(orElse, TInt :: Nil, Expr.ValueVar(x, OptionT(TInt)) :: Expr.ValueVar(x, TInt) :: Nil))
-      res.free.wellformed()
+      res.check()
     }
 
     val ex4: Expr.Make = Make(OptionT(TInt), SomeC, List(), List(Literal(42, TInt)))
     assertSameType(ex4.tpe, OptionT(TInt))
-    assertEquals(ex4.free, Free.defer(ex4))
+    assertEquals(ex4.typing.constraints, Vector(ex4))
 
     val ex5: Expr.Make = Make(OptionT(TInt), NoneC, List(), List())
     assertSameType(ex5.tpe, OptionT(TInt))
-    assertEquals(ex5.free, Free.defer(ex5))
+    assertEquals(ex5.typing.constraints, Vector(ex5))
   }
 
   val ex6 = Stmt.Region(Block.BlockLit(Nil, r :: Nil, Nil, BlockParam(r, TRegion, Set(r)) :: Nil,
@@ -176,6 +167,6 @@ class TypeInferenceTests extends CoreTests {
     assertEquals(Type.equals(got, expected), true)
 
   inline def shouldTypeCheckAs(expected: ValueType, expr: Expr)(using DeclarationContext): Unit =
-    expr.free.wellformed()
+    expr.typing.check()
     assertSameType(expr.tpe, expected)
 }

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

@@ -236,7 +236,7 @@ class VMTests extends munit.FunSuite {
 
   val are_we_fast_yet: Seq[(File, Option[Summary])] = Seq(
     examplesDir / "benchmarks" / "are_we_fast_yet" / "bounce.effekt" -> Some(Summary(
-      staticDispatches = 20202,
+      staticDispatches = 15202,
       dynamicDispatches = 5000,
       patternMatches = 0,
       branches = 31628,
@@ -592,7 +592,7 @@ class VMTests extends munit.FunSuite {
     )),
 
     examplesDir / "benchmarks" / "effect_handlers_bench" / "tree_explore.effekt" -> Some(Summary(
-      staticDispatches = 2077,
+      staticDispatches = 2697,
       dynamicDispatches = 0,
       patternMatches = 2380,
       branches = 3167,
@@ -678,15 +678,15 @@ class VMTests extends munit.FunSuite {
       dynamicDispatches = 15,
       patternMatches = 232,
       branches = 405,
-      pushedFrames = 196,
-      poppedFrames = 196,
+      pushedFrames = 199,
+      poppedFrames = 199,
       allocations = 106,
       closures = 23,
       variableReads = 164,
       variableWrites = 51,
-      resets = 28,
-      shifts = 0,
-      resumes = 0
+      resets = 29,
+      shifts = 3,
+      resumes = 3
     )),
 
     examplesDir / "casestudies" / "parser.effekt.md" -> Some(Summary(
@@ -722,14 +722,14 @@ class VMTests extends munit.FunSuite {
     )),
 
     examplesDir / "casestudies" / "inference.effekt.md" -> Some(Summary(
-      staticDispatches = 1482058,
-      dynamicDispatches = 3224986,
-      patternMatches = 1497945,
+      staticDispatches = 1482042,
+      dynamicDispatches = 3224955,
+      patternMatches = 1497935,
       branches = 304507,
-      pushedFrames = 2643318,
-      poppedFrames = 2066053,
-      allocations = 4654131,
-      closures = 867079,
+      pushedFrames = 2643286,
+      poppedFrames = 2066021,
+      allocations = 4654126,
+      closures = 867068,
       variableReads = 2955965,
       variableWrites = 1480868,
       resets = 288867,
@@ -738,13 +738,13 @@ class VMTests extends munit.FunSuite {
     )),
 
     examplesDir / "pos" / "raytracer.effekt" -> Some(Summary(
-      staticDispatches = 85740,
+      staticDispatches = 71065,
       dynamicDispatches = 0,
-      patternMatches = 763548,
+      patternMatches = 633105,
       branches = 65951,
-      pushedFrames = 43131,
-      poppedFrames = 43131,
-      allocations = 70805,
+      pushedFrames = 31478,
+      poppedFrames = 31478,
+      allocations = 56669,
       closures = 0,
       variableReads = 77886,
       variableWrites = 26904,
@@ -1089,13 +1089,13 @@ class VMTests extends munit.FunSuite {
       resumes = 0
     )),
     examplesDir / "benchmarks" / "nofib" / "constraints.effekt" -> Some(Summary(
-      staticDispatches = 894047,
+      staticDispatches = 903127,
       dynamicDispatches = 60355,
-      patternMatches = 1388933,
+      patternMatches = 1409731,
       branches = 432810,
-      pushedFrames = 797579,
-      poppedFrames = 797579,
-      allocations = 1003044,
+      pushedFrames = 806659,
+      poppedFrames = 806659,
+      allocations = 1023842,
       closures = 10,
       variableReads = 0,
       variableWrites = 0,

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

@@ -10,6 +10,7 @@ import effekt.symbols.Module
 import effekt.typer.{UnboxInference, Typer, Wellformedness}
 import effekt.util.messages.{CompilerPanic, FatalPhaseError}
 import effekt.util.paths
+import effekt.util.debug
 import kiama.output.PrettyPrinterTypes.Document
 import kiama.util.Source
 
@@ -302,7 +303,7 @@ trait Compiler[Executable] {
 
       val aggregated = core.ModuleDecl(main.path, Nil, declarations, externs, definitions, exports)
 
-      if Context.config.debug() then aggregated.typecheck()
+      debug { aggregated.typecheck() }
 
       // TODO in the future check for duplicate exports
       CoreTransformed(src, tree, mod, aggregated)

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

@@ -4,7 +4,7 @@ package core
 import effekt.core.substitutions.Substitution
 
 import scala.collection.mutable
-
+import effekt.util.DB
 
 /**
  * Pattern Matching Compiler
@@ -263,7 +263,7 @@ object PatternMatchingCompiler {
    */
   def normalize(clause: Clause): Clause = clause match {
     case Clause(conditions, label, targs, args) =>
-      val (normalized, substitution) = normalize(Map.empty, conditions, Map.empty)
+      val (normalized, substitution) = normalize(Map.empty, conditions, DB.empty)
       // TODO also substitute types?
       Clause(normalized, label, targs, args.map(v => substitution.getOrElse(v.id, v)))
   }
@@ -284,10 +284,10 @@ object PatternMatchingCompiler {
   def normalize(
     patterns: Map[ValueVar, Pattern],
     conditions: List[Condition],
-    substitution: Map[Id, ValueVar]
-  ): (List[Condition], Map[Id, ValueVar]) = {
+    substitution: DB[ValueVar]
+  ): (List[Condition], DB[ValueVar]) = {
 
-    val subst = Substitution(Map.empty, Map.empty, substitution, Map.empty)
+    val subst = Substitution(DB.empty, DB.empty, substitution, DB.empty)
 
     def prefix(p: Map[ValueVar, Pattern], cs: List[Condition]): List[Condition] =
       if p.isEmpty then cs else Condition.Patterns(p) :: cs
@@ -304,7 +304,7 @@ object PatternMatchingCompiler {
           case (sc, p: Pattern.Tag) => sc -> p
           case (sc, p: Pattern.Literal) => sc -> p
         }
-        normalize(patterns ++ filtered, rest, substitution ++ additionalSubst)
+        normalize(patterns ++ filtered, rest, substitution ++ DB.from(additionalSubst))
 
       case Condition.Run(binding) :: rest =>
         val substituted = core.substitutions.substitute(binding)(using subst)