Merge remote-tracking branch 'lptk-fork/new-definition-typing' into ucs-paper

Author: chengluyu

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

@@ -89,7 +89,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
   private def getFields(etts: List[Statement]): Set[Var] = {
     etts.flatMap{
       case NuFunDef(_, nm, _, _) => Some(nm)
-      case NuTypeDef(_, TypeName(nm), _, _, _, _) => Some(Var(nm))
+      case nuty: NuTypeDef => Some(Var(nuty.name))
       case Let(_, name, _, _) => Some(name)
       case _ => None 
     }.toSet
@@ -180,13 +180,13 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       }.fold(emptyCtx)(_ ++ _)
     case TyApp(trm, tpLst) =>
       getFreeVars(trm).addT(tpLst.flatMap(_.collectTypeNames.map(TypeName(_))))
-    case NuTypeDef(_, nm, tps, param, pars, body) =>
+    case NuTypeDef(_, nm, tps, param, _, pars, _, _, body) =>
       val prmVs = getFreeVars(param)(using emptyCtx, Map(), None)
       val newVs = prmVs.vSet ++ getFields(body.entities) + Var(nm.name)
-      val nCtx = ctx.addV(newVs).addT(nm).addT(tps)
+      val nCtx = ctx.addV(newVs).addT(nm).addT(tps.map(_._2))
       val parVs = pars.map(getFreeVars(_)(using nCtx)).fold(emptyCtx)(_ ++ _)
       val bodyVs = body.entities.map(getFreeVars(_)(using nCtx)).fold(emptyCtx)(_ ++ _)
-      (bodyVs ++ parVs -+ prmVs).extT(tps)
+      (bodyVs ++ parVs -+ prmVs).extT(tps.map(_._2))
     case Blk(stmts) =>
       val newVs = getFields(stmts)
       stmts.map(getFreeVars(_)(using ctx.addV(newVs))).fold(emptyCtx)(_ ++ _)
@@ -197,7 +197,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
   }
 
   private def collectClassInfo(cls: NuTypeDef, preClss: Set[TypeName])(using ctx: LocalContext, cache: ClassCache, outer: Option[ClassInfoCache]): ClassInfoCache = {
-    val NuTypeDef(_, nm, tps, param, pars, body) = cls
+    val NuTypeDef(_, nm, tps, param, _, pars, _, _, body) = cls
     log(s"grep context of ${cls.nme.name} under {\n$ctx\n$cache\n$outer\n}\n")
     val (clses, funcs, trms) = splitEntities(cls.body.entities)
     val (supNms, rcdFlds) = pars.map(getSupClsInfoByTerm).unzip
@@ -209,7 +209,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     }.unzip
     log(s"par record: ${flds._2.flatten}")
     val fields = (param.fields.flatMap(tupleEntityToVar) ++ funcs.map(_.nme) ++ clses.map(x => Var(x.nme.name)) ++ trms.flatMap(grepFieldsInTrm) ++ flds._1).toSet
-    val nCtx = ctx.addV(fields).addV(flds._1).extT(tps)
+    val nCtx = ctx.addV(fields).addV(flds._1).extT(tps.map(_._2))
     val tmpCtx = ((body.entities.map(getFreeVars(_)(using nCtx)) ++ pars.map(getFreeVars(_)(using nCtx))).fold(emptyCtx)(_ ++ _).moveT2V(preClss)
                   ).addT(flds._2.flatten.toSet).extV(supNms.flatten.map(x => Var(x.name)))
 
@@ -379,13 +379,14 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nTpNm = TypeName(genAnoName(t.name))
       val cls = cache.get(t).get
       val supArgs = Tup(cls.body.params.fields.flatMap(tupleEntityToVar).map(toFldsEle))
-      val anoCls = NuTypeDef(Cls, nTpNm, Nil, cls.body.params, List(App(Var(t.name), supArgs)), tu)
+      val anoCls = NuTypeDef(Cls, nTpNm, Nil, cls.body.params, None,
+                    List(App(Var(t.name), supArgs)), None, None, tu)(None)
       val nSta = New(Some((nTpNm, prm)), TypingUnit(Nil))
       val ret = liftEntities(List(anoCls, nSta))
       (Blk(ret._1), ret._2)
     case New(None, tu) =>
       val nTpNm = TypeName(genAnoName())
-      val anoCls = NuTypeDef(Cls, nTpNm, Nil, Tup(Nil), Nil, tu)
+      val anoCls = NuTypeDef(Cls, nTpNm, Nil, Tup(Nil), None, Nil, None, None, tu)(None)
       val nSta = New(Some((nTpNm, Tup(Nil))), TypingUnit(Nil))
       val ret = liftEntities(List(anoCls, nSta))
       (Blk(ret._1), ret._2)
@@ -464,7 +465,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val nlhs = liftType(lb)
       val nrhs = liftType(ub)
       Bounds(nlhs._1, nrhs._1) -> (nlhs._2 ++ nrhs._2)
-    case Constrained(base, bounds, where) =>
+    case Constrained(base: Type, bounds, where) =>
       val (nTargs, nCtx) = bounds.map { case (tv, Bounds(lb, ub)) =>
         val nlhs = liftType(lb)
         val nrhs = liftType(ub)
@@ -478,6 +479,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       val (nBase, bCtx) = liftType(base)
       Constrained(nBase, nTargs, bounds2) ->
         ((nCtx ++ nCtx2).fold(emptyCtx)(_ ++ _) ++ bCtx)
+    case Constrained(_, _, _) => die
     case Function(lhs, rhs) =>
       val nlhs = liftType(lhs)
       val nrhs = liftType(rhs)
@@ -531,7 +533,7 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     case PolyType(targs, body) =>
       val (body2, ctx) = liftType(body)
       PolyType(targs, body2) -> ctx
-    case Top | Bot | _: Literal | _: TypeTag | _: TypeVar => target -> emptyCtx
+    case Top | Bot | _: Literal | _: TypeTag | _: TypeVar => target.asInstanceOf[Type] -> emptyCtx
   }
 
 
@@ -541,14 +543,14 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     body match{
       case Left(value) =>
         val ret = liftTerm(value)(using ctx.addV(nm).addT(tpVs))
-        (func.copy(rhs = Left(ret._1)), ret._2)
+        (func.copy(rhs = Left(ret._1))(None), ret._2)
       case Right(PolyType(targs, body)) =>
         val nBody = liftType(body)(using ctx.addT(tpVs))
         val nTargs = targs.map {
           case L(tp) => liftTypeName(tp)(using ctx.addT(tpVs)).mapFirst(Left.apply)
           case R(tv) => R(tv) -> emptyCtx
         }.unzip
-        (func.copy(rhs = Right(PolyType(nTargs._1, nBody._1))), nTargs._2.fold(nBody._2)(_ ++ _))
+        (func.copy(rhs = Right(PolyType(nTargs._1, nBody._1)))(None), nTargs._2.fold(nBody._2)(_ ++ _))
     }
   }
 
@@ -624,14 +626,14 @@ class ClassLifter(logDebugMsg: Boolean = false) {
       ).flatten.toMap
     }
     log("lift type " + target.toString() + " with cache " + cache.toString())
-    val NuTypeDef(kind, nme, tps, params, pars, body) = target
+    val NuTypeDef(kind, nme, tps, params, sig, pars, supAnn, thisAnn, body) = target
     val nOuter = cache.get(nme)
     val ClassInfoCache(_, nName, freeVs, flds, inners, sups, _, _, _) = nOuter.get
     val (clsList, funcList, termList) = splitEntities(body.entities)
     val innerNmsSet = clsList.map(_.nme).toSet
 
     val nCache = cache ++ inners ++ getAllInners(sups)
-    val nTps = (tps ++ (freeVs.tSet -- nCache.keySet).toList).distinct
+    val nTps = (tps.map(_._2) ++ (freeVs.tSet -- nCache.keySet).toList).distinct
     val nCtx = freeVs.addT(nTps)
     val nParams = 
       outer.map(x => List(toFldsEle(Var(genParName(x.liftedNm.name))))).getOrElse(Nil)
@@ -641,7 +643,9 @@ class ClassLifter(logDebugMsg: Boolean = false) {
     val nFuncs = funcList.map(liftFunc(_)(using emptyCtx, nCache, nOuter)).unzip
     val nTerms = termList.map(liftTerm(_)(using emptyCtx, nCache, nOuter)).unzip
     clsList.foreach(x => liftTypeDefNew(x)(using nCache, nOuter))
-    retSeq = retSeq.appended(NuTypeDef(kind, nName, nTps, Tup(nParams), nPars._1, TypingUnit(nFuncs._1 ++ nTerms._1)))
+    retSeq = retSeq.appended(NuTypeDef(
+      kind, nName, nTps.map((None, _)), Tup(nParams), None, nPars._1,
+      None, None, TypingUnit(nFuncs._1 ++ nTerms._1))(None))
   }
 
   def liftTypingUnit(rawUnit: TypingUnit): TypingUnit = {

compiler/shared/main/scala/mlscript/compiler/PrettyPrinter.scala

@@ -36,17 +36,17 @@ object PrettyPrinter:
       case Some(true) => "let'"
     }
     s"$st ${funDef.nme.name}"
-      + (if funDef.targs.isEmpty
+      + (if funDef.tparams.isEmpty
          then ""
-         else funDef.targs.map(_.name).mkString("[", ", ", "]"))
+         else funDef.tparams.map(_.name).mkString("[", ", ", "]"))
       + " = "
       + funDef.rhs.fold(_.toString, _.show)
 
   def showTypeDef(tyDef: NuTypeDef, indent: Int = 0): String =
     s"${tyDef.kind.str} ${tyDef.nme.name}"
       + (if tyDef.tparams.isEmpty
          then ""
-         else tyDef.tparams.map(_.name).mkString("[", ",", "]"))
+         else tyDef.tparams.map(_._2.name).mkString("[", ",", "]"))
       + "(" + tyDef.params + ")"
       + (if tyDef.parents.isEmpty
          then ""