Very WIP: Implement Monomorphization optimization

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

@@ -0,0 +1,112 @@
+package effekt
+package core
+
+
+abstract class AbstractMonoTests extends CorePhaseTests(Mono) {
+    import TypeArg.*
+
+    implicit def stringBaseT(name: String): Base = Base(Id(name), List())
+
+    val BaseTInt: Base = "Int"
+    val BaseTString: Base = "String"
+    val BaseTChar: Base = "Char"
+    val BaseTBool: Base = "Bool"
+    val BaseTDouble: Base = "Double"
+
+    val fnId: Map[String, FunctionId] = Map(
+        "a" -> Id("a"),
+        "b" -> Id("b"),
+        "c" -> Id("c"),
+        "d" -> Id("d"),
+        "e" -> Id("e"),
+        "f" -> Id("f"),
+    )
+}
+
+class MonoTests extends AbstractMonoTests {
+
+    import TypeArg.*
+
+    test("simple polymorphic function") {
+        val constraints = List(
+            Constraint(Vector(BaseTInt), fnId("a")),
+            Constraint(Vector(BaseTString), fnId("a"))
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(Vector(BaseTInt), Vector(BaseTString))
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+
+    test("calling other polymorphic function") {
+        val constraints = List(
+            Constraint(Vector(Var(fnId("b"), 0)), fnId("a")),
+            Constraint(Vector(BaseTInt), fnId("a")),
+            Constraint(Vector(BaseTString), fnId("b")),
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(Vector(BaseTInt), Vector(BaseTString)),
+            fnId("b") -> Set(Vector(BaseTString)),
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+
+    test("polymorphic function with multiple type args") {
+        val constraints = List(
+            Constraint(Vector(BaseTInt, BaseTString), fnId("a")),
+            Constraint(Vector(BaseTBool, BaseTChar), fnId("a")),
+            Constraint(Vector(BaseTBool, BaseTString), fnId("a")),
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(
+                Vector(BaseTInt, BaseTString),
+                Vector(BaseTBool, BaseTChar),
+                Vector(BaseTBool, BaseTString),
+            )
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+
+    test("calling other polymorphic function with type args swapped") {
+        val constraints = List(
+            Constraint(Vector(Var(fnId("b"), 1), Var(fnId("b"), 0)), fnId("a")),
+            Constraint(Vector(BaseTString, BaseTBool), fnId("b")),
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(Vector(BaseTBool, BaseTString)),
+            fnId("b") -> Set(Vector(BaseTString, BaseTBool)),
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+
+    test("recursive polymorphic function") {
+        val constraints = List(
+            Constraint(Vector(Var(fnId("a"), 0)), fnId("a")),
+            Constraint(Vector(BaseTInt), fnId("a")),
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(Vector(BaseTInt)),
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+
+    test("mutually recursive polymorphic functions") {
+        val constraints = List(
+            Constraint(Vector(Var(fnId("b"), 0)), fnId("a")),
+            Constraint(Vector(Var(fnId("a"), 0)), fnId("b")),
+            Constraint(Vector(BaseTInt), fnId("a")),
+            Constraint(Vector(BaseTString), fnId("b")),
+        )
+        val expectedSolved: Solution = Map(
+            fnId("a") -> Set(Vector(BaseTInt), Vector(BaseTString)),
+            fnId("b") -> Set(Vector(BaseTInt), Vector(BaseTString)),
+        )
+
+        assertEquals(solveConstraints(constraints), expectedSolved)
+    }
+}

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

@@ -0,0 +1,20 @@
+package effekt.core
+
+import effekt.PhaseResult.CoreTransformed
+import effekt.context.Context
+import effekt.core.optimizer.Deadcode
+import effekt.Phase
+
+object DeadCodeElimination extends Phase[CoreTransformed, CoreTransformed] {
+    val phaseName: String = "deadcode-elimination"
+
+    def run(input: CoreTransformed)(using Context): Option[CoreTransformed] =
+        input match {
+            case CoreTransformed(source, tree, mod, core) => 
+                val term = Context.ensureMainExists(mod)
+                val dce = Context.timed("deadcode-elimination", source.name) {
+                    Deadcode.remove(term, core)
+                }
+                Some(CoreTransformed(source, tree, mod, dce))
+        }
+}