Preliminary deforestation implementation for hkmc2

hkmc2/shared/src/main/scala/hkmc2/Uid.scala

@@ -13,6 +13,7 @@ object Uid:
         curUid
       def reset = curUid = -1
   object Symbol extends Handler[semantics.Symbol]
+  object StratVar extends Handler[codegen.deforest.StratVarState]
 
 extension [T] (x: Uid[T])
   def <=(rhs: Uid[T]) = x <= rhs

hkmc2/shared/src/main/scala/hkmc2/codegen/Block.scala

@@ -412,6 +412,11 @@ enum Case:
 
 sealed trait TrivialResult extends Result
 
+object Result:
+  opaque type ResultId = Int
+  private def ResultId(v: Int): ResultId = v
+
+
 sealed abstract class Result extends AutoLocated:
 
   protected def children: List[Located] = this match
@@ -465,6 +470,13 @@ sealed abstract class Result extends AutoLocated:
     case DynSelect(qual, fld, arrayIdx) => qual.freeVarsLLIR ++ fld.freeVarsLLIR
     case Value.Rcd(args) => args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVarsLLIR) ++ arg.value.freeVarsLLIR).toSet
 
+  def uid =
+    import Result.*
+    val uidValue = ResultId(System.identityHashCode(this))
+    uidValue
+
+
+
 // type Local = LocalSymbol
 type Local = Symbol
 

hkmc2/shared/src/main/scala/hkmc2/codegen/LambdaRewriter.scala

@@ -24,7 +24,10 @@ object LambdaRewriter:
         val lambdaRewriter = new BlockDataTransformer(SymbolSubst()):
           override def applyValue(v: Value): Value = v match
             case lam: Value.Lam => 
-              val sym = BlockMemberSymbol("lambda", Nil, nameIsMeaningful = false)
+              val sym = BlockMemberSymbol(
+                "lambda",
+                syntax.Tree.TermDef(syntax.Fun, syntax.Tree.Empty(), N) :: Nil,
+                nameIsMeaningful = false)
               lambdasList ::= (sym -> super.applyLam(lam))
               Value.Ref(sym)
             case _ => super.applyValue(v)

hkmc2/shared/src/main/scala/hkmc2/codegen/deforest/Deforest.scala

@@ -0,0 +1,42 @@
+package hkmc2
+package codegen
+package deforest
+
+import semantics.*
+import syntax.Tree
+import utils.*
+import mlscript.utils.*, shorthands.*
+import scala.collection.mutable
+import Result.ResultId
+
+
+object Deforest:
+  class State:
+    val topLevelFunSymToFunDefn = collection.mutable.Map.empty[BlockMemberSymbol, FunDefn]
+
+  def apply(p: Program)(using State, Elaborator.State): Either[Program -> String -> String, String] =
+    try
+      val pre = new DeforestPreAnalyzer(p.main)
+      val col = new DeforestConstraintsCollector(pre)
+      val ana = new DeforestConstrainSolver(col)
+      val rwp = new DeforestRewritePrepare(ana)
+      val rw = new DeforestRewriter(rwp)
+      val detail = col.constraints
+        .map: (p, c) =>
+          (s"$p --> $c")
+        .mkString("\n")
+      val summary = rwp.ctorIdToFinalDest
+        .map: (ctorid, dest) =>
+          pre.getResult(ctorid._1).toString() +
+          "@" +
+          pre.getStableResultId(ctorid._1) +
+          "@" +
+          ctorid._2.makeSuffix(pre) +
+          " --> " +
+          dest.toString(pre)
+        .mkString("\n")
+      val deforestRes = rw()
+      L:
+        Program(p.imports, deforestRes) -> summary -> detail
+    catch
+      case NotDeforestableException(msg) => R(msg)