Suggested changes

Author: HarrisL2

compiler/shared/main/scala/mlscript/compiler/ClassLifter.scala

@@ -9,7 +9,7 @@ import scala.collection.mutable.Set as MutSet
 import scala.collection.mutable.ArrayBuffer as ArrayBuffer
 import mlscript.codegen.CodeGenError
 
-class MonomorphError(error: String) extends Error(error)
+class CompilerError(error: String) extends Error(error)
 
 class ClassLifter(logDebugMsg: Boolean = false) {
   type ClassName = String
@@ -250,7 +250,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nE = liftTerm(expr)
       val nR = liftTerm(rhs)
       (IfThen(nE._1, nR._1), nE._2 ++ nR._2)
-    case _ => throw MonomorphError(s"Unknown IfBody: ${body}")
+    case _ => throw CompilerError(s"Unknown IfBody: ${body}")
   }
 
   private def liftTuple(tup: Tup)(using ctx: LocalContext, cache: ClassCache, globFuncs: Map[Var, (Var, LocalContext)], outer: Option[ClassInfoCache]): (Tup, LocalContext) = {
@@ -400,7 +400,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     case Sel(receiver, fieldName) =>
       val nRec = liftTerm(receiver)
       (Sel(nRec._1, fieldName), nRec._2)
-    case Splc(fields) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case Splc(fields) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case Subs(arr, idx) =>
       val (ltrm, lctx) = liftTerm(arr)
       val (rtrm, rctx) = liftTerm(idx)
@@ -413,7 +413,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val ret = liftTerm(lhs)
       val nTs = targs.map(liftType).unzip
       (TyApp(ret._1, nTs._1), nTs._2.fold(ret._2)(_ ++ _))
-    case With(trm, fields) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case With(trm, fields) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case New(Some((t: TypeName, prm: Tup)), TypingUnit(Nil)) =>
       val ret = liftConstr(t, prm)
       (New(Some((ret._1, ret._2)), TypingUnit(Nil)), ret._3)
@@ -433,7 +433,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nSta = New(Some((nTpNm, Tup(Nil))), TypingUnit(Nil))
       val ret = liftEntities(List(anoCls, nSta))
       (Blk(ret._1), ret._2)
-    case New(head, body) => throw MonomorphError(s"Unimplemented liftTerm: ${target}")
+    case New(head, body) => throw CompilerError(s"Unimplemented liftTerm: ${target}")
     case Blk(stmts) =>
       val ret = liftEntities(stmts)
       (Blk(ret._1), ret._2)
@@ -448,7 +448,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val (bod2, ctx) = liftTerm(bod)
       val (sts2, ctx2) = liftEntities(sts)
       (Where(bod2, sts2), ctx2)
-    case _: Eqn | _: Super | _: Rft | _: While | _: Quoted | _: Unquoted | _: Ann => throw MonomorphError(s"Unimplemented liftTerm: ${target}") // TODO
+    case _: Eqn | _: Super | _: Rft | _: While | _: Quoted | _: Unquoted | _: Ann => throw CompilerError(s"Unimplemented liftTerm: ${target}") // TODO
     case patmat: AdtMatchWith => lastWords(s"Cannot liftTermNew ${patmat}")
   }
 
@@ -485,7 +485,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
           ((v, Fld(flags, tmp._1)), tmp._2)
       }.unzip
       (Rcd(ret._1), ret._2.fold(emptyCtx)(_ ++ _))
-    case _ => throw MonomorphError(s"Unimplemented liftTermAsType: ${target}")
+    case _ => throw CompilerError(s"Unimplemented liftTermAsType: ${target}")
   }
 
   private def liftTypeName(target: TypeName)(using ctx: LocalContext, cache: ClassCache, globFuncs: Map[Var, (Var, LocalContext)], outer: Option[ClassInfoCache]): (TypeName, LocalContext) = {
@@ -579,7 +579,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val (body2, ctx) = liftType(body)
       PolyType(targs, body2) -> ctx
     case Top | Bot | _: Literal | _: TypeTag | _: TypeVar => target.asInstanceOf[Type] -> emptyCtx
-    case _: Selection => throw MonomorphError(s"Unimplemented liftType: ${target}") // TODO
+    case _: Selection => throw CompilerError(s"Unimplemented liftType: ${target}") // TODO
   }
 
 
@@ -603,7 +603,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
         }.unzip
         (func.copy(rhs = Right(PolyType(nTargs._1, nBody._1)))(func.declareLoc, func.virtualLoc, func.mutLoc, func.signature, func.outer, func.genField, func.annotations),
           nTargs._2.fold(nBody._2)(_ ++ _))
-      case _ => throw MonomorphError(s"Unimplemented liftMemberFunc: ${func}") // TODO
+      case _ => throw CompilerError(s"Unimplemented liftMemberFunc: ${func}") // TODO
     }
   }
 
@@ -630,7 +630,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
               case (tn, ctx) => (L(tn), ctx)
           case R(tv) => R(tv) -> emptyCtx}).unzip
         NuFunDef(rec, globFuncs.get(nm).get._1, N, nTpVs, Right(PolyType(nTargs._1, nBody._1)))(N, N, N, N, N, true, Nil) 
-      case _ => throw MonomorphError(s"Unimplemented liftGlobalFunc: ${func}")
+      case _ => throw CompilerError(s"Unimplemented liftGlobalFunc: ${func}")
     })
   }
 

compiler/shared/main/scala/mlscript/compiler/simpledef/Simpledef.scala

@@ -18,7 +18,6 @@ type Cnstr = ProdStrat -> ConsStrat
  *  Lastly, we rewrite selection terms by generating pattern matches on their possible inputs.
  */
 
-
 enum ProdStrat(using val euid: TermId) {
   case NoProd()(using TermId) 
   case ProdObj(ctor: Option[Var], fields: Ls[Var -> ProdStrat], parents: Ls[ProdStrat] = Nil)(using TermId) extends ProdStrat, ProdObjImpl
@@ -45,8 +44,8 @@ trait ProdObjImpl { self: ProdObj =>
 
 class Context(
   variables: Map[Var, ProdVar],
-  classes: Map[Var, ProdObj]) 
-{
+  classes: Map[Var, ProdObj],
+) {
   def apply(v: Var): ProdVar =
     variables(v)
   def ++(other: IterableOnce[(Var, ProdVar)]): Context =
@@ -271,7 +270,7 @@ class SimpleDef(debug: Debug) {
         apply(TypingUnit(stmts))._2
       case Bra(false, term) =>
         process(term)
-      case CaseOf(trm, cases) => //TODO
+      case CaseOf(trm, cases) => // TODO: Complete constraining in conjunction with processCases
         ???
       case Eqn(lhs, rhs) =>
         process(lhs)
@@ -281,7 +280,7 @@ class SimpleDef(debug: Debug) {
     debug.outdent()
     registerTermToType(t, res)
 
-  //TODO
+  // TODO: Complete constraining for CaseBranches after implementing negative types and intersections
   def processCases(scrut: ProdVar, cs: CaseBranches)(using ctx: Context, resCons: ConsVar): Unit =
     cs match
       case Wildcard(body) => 

compiler/shared/test/scala/mlscript/compiler/Test.scala

@@ -37,7 +37,6 @@ class DiffTestCompiler extends DiffTests {
       val pd = SimpleDef(treeDebug)
       pd(rstUnit)
       val defuncAST = pd.rewriteProgram(rstUnit)
-      //output(s"${defuncAST}\n")
       output(defuncAST.showDbg.replace(";", "\n"))
       output("End simpledef\n")
       return (outputBuilder.toString().linesIterator.toList, Some(defuncAST))
@@ -48,6 +47,21 @@ class DiffTestCompiler extends DiffTests {
       (outputBuilder.toString().linesIterator.toList, None)
     }
 
+  override def postTypingProcess(mode: ModeType, basePath: List[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (List[Str], Option[TypingUnit]) = 
+    val outputBuilder = StringBuilder()
+
+    if(mode.simpledef || basePath.contains("Defunctionalize")) {
+      output("\nSimpledef:")
+      val treeDebug = new TreeDebug(if mode.dbgSimpledef then output else (str) => ())
+      val pd = SimpleDef(treeDebug)
+      pd(unit)
+      val defuncAST = pd.rewriteProgram(unit)
+      output(defuncAST.showDbg.replace(";", "\n"))
+      output("End simpledef\n")
+      return (outputBuilder.toString().linesIterator.toList, Some(defuncAST))
+    }
+    (outputBuilder.toString().linesIterator.toList, None)
+    
   override protected lazy val files = allFiles.filter { file =>
       val fileName = file.baseName
       validExt(file.ext) && filter(file.relativeTo(pwd))

shared/src/test/scala/mlscript/DiffTests.scala

@@ -58,6 +58,7 @@ class DiffTests
 
   /**  Hook for dependent projects, like the monomorphizer. */
   def postProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
+  def postTypingProcess(mode: ModeType, basePath: Ls[Str], testName: Str, unit: TypingUnit, output: Str => Unit): (Ls[Str], Option[TypingUnit]) = (Nil, None)
 
 
   @SuppressWarnings(Array("org.wartremover.warts.RedundantIsInstanceOf"))
@@ -913,7 +914,7 @@ class DiffTests
               import codeGenTestHelpers._
               val pp = 
                 if (mode.postProcessAfterTyping) {
-                 Pgrm(postProcess(mode, basePath, testName, TypingUnit(p.tops), output)._2.fold(???)(_.entities)) 
+                  Pgrm(postTypingProcess(mode, basePath, testName, TypingUnit(p.tops), output)._2.fold(???)(_.entities)) 
                 } else { 
                   p
                 }