Refactor code generation for local definitions & annotations + fix various problems

Author: LPTK

hkmc2/shared/src/main/scala/hkmc2/MLsCompiler.scala

@@ -71,16 +71,19 @@ class MLsCompiler(preludeFile: os.Path):
 
     newCtx.nest(N).givenIn:
 
-      val (blk, newCtx) = elab.importFrom(mainParse.resultBlk)
+      val parsed = mainParse.resultBlk
+      val (blk, newCtx) = elab.importFrom(parsed)
       val low = ltl.givenIn:
         codegen.Lowering(lowerHandlers = false)
       val jsb = codegen.js.JSBuilder()
       val le = low.program(blk)
       val baseScp: utils.Scope =
         utils.Scope.empty
       val nestedScp = baseScp.nest
+      val nme = file.baseName
+      val exportedSymbol = parsed.definedSymbols.find(_._1 === nme).map(_._2)
       val je = nestedScp.givenIn:
-        jsb.program(le, S(file.baseName), wd)
+        jsb.program(le, exportedSymbol, wd)
       val jsStr = je.stripBreaks.mkString(100)
       val out = file / os.up / (file.baseName + ".mjs")
       os.write.over(out, jsStr)

hkmc2/shared/src/main/scala/hkmc2/bbml/bbML.scala

@@ -69,7 +69,7 @@ object BbCtx:
   def init(raise: Raise)(using Elaborator.State, Elaborator.Ctx): BbCtx =
     new BbCtx(raise, summon, None, 1, HashMap.empty, Bot, N)
 
-  val builtinOps = Set("+", "-", "*", "/", "<", ">", "<=", ">=", "==", "!=", "&&", "||")
+  val builtinOps = Elaborator.binaryOps ++ Elaborator.unaryOps ++ Elaborator.aliasOps.keySet
 end BbCtx
 
 
@@ -84,8 +84,8 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
   private def freshVar(sym: Symbol, hint: Str = "")(using ctx: BbCtx): InfVar =
     InfVar(ctx.lvl, infVarState.nextUid, new VarState(), false)(sym, hint)
   private def freshWildcard(sym: Symbol)(using ctx: BbCtx) =
-    val in = freshVar(sym, "-")
-    val out = freshVar(sym, "+")
+    val in = freshVar(sym, "")
+    val out = freshVar(sym, "")
     // in.state.upperBounds ::= out // * Not needed for soundness; complicates inferred types
     Wildcard(in, out)
   private def freshReg(sym: Symbol)(using ctx: BbCtx) =
@@ -138,8 +138,8 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       // log(s"Type application: ${cls.nme} with ${targs}")
       cls.symbol.flatMap(_.asTpe) match
       case S(tpeSym) =>
-        if tpeSym.nme === "Any" then Top
-        else if tpeSym.nme === "Nothing" then Bot
+        if tpeSym.nme === "Any" then Top // FIXME hygiene
+        else if tpeSym.nme === "Nothing" then Bot // FIXME hygiene
         else
           val defn = tpeSym.defn.get
           if targs.length != defn.tparams.length then
@@ -425,6 +425,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
   trace[(GeneralType, Type)](s"${ctx.lvl}. Typing ${t.showDbg}", res => s": (${res._1.showDbg}, ${res._2.showDbg})"):
     given CCtx = CCtx.init(t, N)
     t match
+      case Term.Annotated(Annot.Untyped, _) => (Bot, Bot)
       case sel @ Term.SynthSel(Ref(_: TopLevelSymbol), nme)
         if sel.symbol.isDefined =>
         typeCheck(Ref(sel.symbol.get)(sel.nme, 666)) // FIXME 666
@@ -507,8 +508,6 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
               case _ => (error(msg"${field.name} is not a valid member in class ${clsSym.nme}" -> t.toLoc :: Nil), Bot)
           case N => 
             (error(msg"Not a valid class: ${cls.describe}" -> cls.toLoc :: Nil), Bot)
-      case Term.App(lhs: Term.SynthSel, Term.Tup(Nil)) if lhs.sym.exists(_.isGetter) =>
-        typeCheck(lhs) // * Getter access will be elaborated to applications. But they cannot be typed as normal applications.
       case t @ Term.App(lhs, Term.Tup(rhs)) =>
         val (funTy, lhsEff) = typeCheck(lhs)
         app((funTy, lhsEff), rhs, t)

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

@@ -36,7 +36,9 @@ sealed abstract class Block extends Product with AutoLocated:
     case End(_) => Set.empty
     case Break(_) => Set.empty
     case Continue(_) => Set.empty
-    case Define(defn, rst) => rst.definedVars
+    case Define(defn, rst) =>
+      val rest = rst.definedVars
+      if defn.isOwned then rest else rest + defn.sym
     case HandleBlock(lhs, res, par, cls, hdr, bod, rst) => bod.definedVars ++ rst.definedVars + lhs
     case HandleBlockReturn(_) => Set.empty
     case TryBlock(sub, fin, rst) => sub.definedVars ++ fin.definedVars ++ rst.definedVars
@@ -86,7 +88,17 @@ sealed abstract class Block extends Product with AutoLocated:
       (bod.freeVars - lhs) ++ rst.freeVars ++ hdr.flatMap(_.freeVars)
     case HandleBlockReturn(res) => res.freeVars
     case End(msg) => Set.empty
-
+  
+  lazy val subBlocks: Ls[Block] = this match
+    case Match(_, arms, dflt, rest) => arms.map(_._2) ++ dflt.toList :+ rest
+    case Begin(sub, rest) => sub :: rest :: Nil
+    case TryBlock(sub, finallyDo, rest) => sub :: finallyDo :: rest :: Nil
+    case Assign(_, rhs, rest) => rest :: Nil
+    case AssignField(_, _, rhs, rest) => rest :: Nil
+    case Define(_, rest) => rest :: Nil
+    case HandleBlock(_, _, _, _, handlers, body, rest) => handlers.map(_.body) :+ body :+ rest
+    case _: Return | _: Throw | _: Label | _: Break | _: Continue | _: End | _: HandleBlockReturn => Nil
+  
   def floatOutDefns =
     def rec(b: Block, acc: List[Defn]): (Block, List[Defn]) = b match
       case Match(scrut, arms, dflt, rest) =>
@@ -143,7 +155,7 @@ sealed abstract class Block extends Product with AutoLocated:
       case HandleBlockReturn(res) => (b, acc)
       case End(msg) => (b, acc)
     rec(this, Nil)
-
+  
 end Block
 
 sealed abstract class BlockTail extends Block
@@ -178,43 +190,62 @@ case class AssignField(lhs: Path, nme: Tree.Ident, rhs: Result, rest: Block)(val
 
 case class Define(defn: Defn, rest: Block) extends Block with ProductWithTail
 
-case class HandleBlock(lhs: Local, res: Local, par: Path, cls: ClassSymbol, handlers: Ls[Handler], body: Block, rest: Block) extends Block with ProductWithTail
+case class HandleBlock(
+    lhs: Local,
+    res: Local,
+    par: Path,
+    cls: ClassSymbol,
+    handlers: Ls[Handler],
+    body: Block,
+    rest: Block
+) extends Block with ProductWithTail
+
 case class HandleBlockReturn(res: Result) extends BlockTail
 
 sealed abstract class Defn:
-  val sym: MemberSymbol[?]
+  val innerSym: Opt[MemberSymbol[?]]
+  val sym: BlockMemberSymbol
+  def isOwned: Bool = owner.isDefined
+  def owner: Opt[InnerSymbol]
 
   lazy val freeVars: Set[Local] = this match
-    case FunDefn(sym, params, body) => body.freeVars -- params.flatMap(_.paramSyms) - sym
+    case FunDefn(own, sym, params, body) => body.freeVars -- params.flatMap(_.paramSyms) - sym
     case ValDefn(owner, k, sym, rhs) => rhs.freeVars
-    case ClsLikeDefn(sym, k, parentSym, methods, privateFields, publicFields, preCtor, ctor) =>
+    case ClsLikeDefn(own, isym, sym, k, paramsOpt, parentSym, methods, privateFields, publicFields, preCtor, ctor) =>
       preCtor.freeVars
         ++ ctor.freeVars ++ methods.flatMap(_.freeVars)
         -- privateFields -- publicFields.map(_.sym)
 
 final case class FunDefn(
+    owner: Opt[InnerSymbol],
     sym: BlockMemberSymbol,
     params: Ls[ParamList],
     body: Block,
-) extends Defn
+) extends Defn:
+  val innerSym = N
 
 final case class ValDefn(
     owner: Opt[InnerSymbol],
     k: syntax.Val,
     sym: BlockMemberSymbol,
     rhs: Path,
-) extends Defn
+) extends Defn:
+  val innerSym = N
 
 final case class ClsLikeDefn(
-  sym: MemberSymbol[? <: ClassLikeDef],
-  k: syntax.ClsLikeKind,
-  parentPath: Opt[Path],
-  methods: Ls[FunDefn],
-  privateFields: Ls[TermSymbol],
-  publicFields: Ls[TermDefinition],
-  preCtor: Block,
-  ctor: Block,
-) extends Defn
+    owner: Opt[InnerSymbol],
+    isym: MemberSymbol[? <: ClassLikeDef],
+    sym: BlockMemberSymbol,
+    k: syntax.ClsLikeKind,
+    paramsOpt: Opt[ParamList],
+    parentPath: Opt[Path],
+    methods: Ls[FunDefn],
+    privateFields: Ls[TermSymbol],
+    publicFields: Ls[TermDefinition],
+    preCtor: Block,
+    ctor: Block,
+) extends Defn:
+  val innerSym = S(isym)
 
 final case class Handler(
     sym: BlockMemberSymbol,

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

@@ -7,11 +7,12 @@ import hkmc2.utils.*
 import semantics.*
 import os.write.over
 
+
 // Default implementation: nothing is transformed
 class BlockTransformer(subst: SymbolSubst):
-
+  
   given SymbolSubst = subst
-
+  
   def applyBlock(b: Block): Block = b match
     case _: End => b
     case Break(lbl) =>
@@ -31,15 +32,15 @@ class BlockTransformer(subst: SymbolSubst):
         if res2 is res then b else HandleBlockReturn(res2)
     case Match(scrut, arms, dflt, rst) =>
       val scrut2 = applyPath(scrut)
-      val arms2 = arms.map: arm =>
+      val arms2 = arms.mapConserve: arm =>
         val cse2 = applyCase(arm._1)
         val blk2 = applyBlock(arm._2)
         if (cse2 is arm._1) && (blk2 is arm._2) then arm else (cse2, blk2)
-      val dflt2 = dflt.map(applyBlock)
+      val dflt2 = dflt.mapConserve(applyBlock)
       val rst2 = applyBlock(rst)
       if (scrut2 is scrut) &&
-          (arms2 zip arms).forall(_ is _) &&
-          (dflt2 zip dflt).forall(_ is _) && (rst2 is rst)
+          (arms2 is arms) &&
+          (dflt2 is dflt) && (rst2 is rst)
         then b else Match(scrut2, arms2, dflt2, rst2)
     case Label(lbl, bod, rst) =>
       val lbl2 = applyLocal(lbl)
@@ -64,8 +65,8 @@ class BlockTransformer(subst: SymbolSubst):
       applyResult2(r): r2 =>
         val l2 = applyPath(l)
         val rst2 = applyBlock(rst)
-        val sym = b.symbol.map(_.subst)
-        if (l2 is l) && (r2 is r) && (rst2 is rst) && (sym zip b.symbol).forall(_ is _)
+        val sym = b.symbol.mapConserve(_.subst)
+        if (l2 is l) && (r2 is r) && (rst2 is rst) && (sym is b.symbol)
           then b else AssignField(l2, n, r2, rst2)(sym)
     case Define(defn, rst) =>
       val defn2 = applyDefn(defn)
@@ -76,31 +77,31 @@ class BlockTransformer(subst: SymbolSubst):
       val res2 = applyLocal(res)
       val par2 = applyPath(par)
       val cls2 = cls.subst
-      val hdr2 = hdr.map(applyHandler)
+      val hdr2 = hdr.mapConserve(applyHandler)
       val bod2 = applyBlock(bod)
       val rst2 = applyBlock(rst)
       if (l2 is l) && (res2 is res) && (par2 is par) && (cls2 is cls) &&
-          (hdr2 zip hdr).forall(_ is _) && (bod2 is bod) && (rst2 is rst)
+          (hdr2 is hdr) && (bod2 is bod) && (rst2 is rst)
         then b else HandleBlock(l2, res2, par2, cls2, hdr2, bod2, rst2)
 
   def applyResult2(r: Result)(k: Result => Block): Block = k(applyResult(r))
 
   def applyResult(r: Result): Result = r match
     case r @ Call(fun, args) =>
       val fun2 = applyPath(fun)
-      val args2 = args.map(applyArg)
-      if (fun2 is fun) && (args2 zip args).forall(_ is _) then r else Call(fun2, args2)(r.isMlsFun)
+      val args2 = args.mapConserve(applyArg)
+      if (fun2 is fun) && (args2 is args) then r else Call(fun2, args2)(r.isMlsFun)
     case Instantiate(cls, args) =>
       val cls2 = applyPath(cls)
-      val args2 = args.map(applyPath)
-      if (cls2 is cls) && (args2 zip args).forall(_ is _) then r else Instantiate(cls2, args2)
+      val args2 = args.mapConserve(applyPath)
+      if (cls2 is cls) && (args2 is args) then r else Instantiate(cls2, args2)
     case p: Path => applyPath(p)
 
   def applyPath(p: Path): Path = p match
     case p @ Select(qual, name) =>
       val qual2 = applyPath(qual)
-      val sym2 = p.symbol.map(_.subst)
-      if (qual2 is qual) && (sym2 zip p.symbol).forall(_ is _) then p else Select(qual2, name)(sym2)
+      val sym2 = p.symbol.mapConserve(_.subst)
+      if (qual2 is qual) && (sym2 is p.symbol) then p else Select(qual2, name)(sym2)
     case v: Value => applyValue(v)
 
   def applyValue(v: Value): Value = v match
@@ -113,40 +114,46 @@ class BlockTransformer(subst: SymbolSubst):
     case Value.Lit(lit) => v
     case v @ Value.Lam(params, body) => applyLam(v)
     case Value.Arr(elems) =>
-      val elems2 = elems.map(applyArg)
-      if (elems2 zip elems).forall(_ is _) then v else Value.Arr(elems2)
+      val elems2 = elems.mapConserve(applyArg)
+      if (elems2 is elems) then v else Value.Arr(elems2)
 
   def applyLocal(sym: Local): Local = sym.subst
-
+  
   def applyFunDefn(fun: FunDefn): FunDefn =
+    val own2 = fun.owner.mapConserve(_.subst)
     val sym2 = fun.sym.subst
-    val params2 = fun.params.map(applyParamList)
+    val params2 = fun.params.mapConserve(applyParamList)
     val body2 = applyBlock(fun.body)
-    if (sym2 is fun.sym) && (params2 zip fun.params).forall(_ is _) && (body2 is fun.body)
-      then fun else FunDefn(sym2, params2, body2)
+    if (own2 is fun.owner) && (sym2 is fun.sym) && (params2 is fun.params) && (body2 is fun.body)
+      then fun else FunDefn(own2, sym2, params2, body2)
 
   def applyDefn(defn: Defn): Defn = defn match
-    case defn @ FunDefn(sym, params, body) => applyFunDefn(defn)
+    case defn: FunDefn => applyFunDefn(defn)
     case ValDefn(owner, k, sym, rhs) =>
-      val owner2 = owner.map(_.subst)
+      val owner2 = owner.mapConserve(_.subst)
       val sym2 = sym.subst
       val rhs2 = applyPath(rhs)
-      if (owner2 zip owner).forall(_ is _) && (sym2 is sym) && (rhs2 is rhs)
+      if (owner2 is owner) && (sym2 is sym) && (rhs2 is rhs)
         then defn else ValDefn(owner2, k, sym2, rhs2)
-    case ClsLikeDefn(sym, k, parentPath, methods, privateFields, publicFields, preCtor, ctor) =>
+    case ClsLikeDefn(own, isym, sym, k, paramsOpt, parentPath, methods, privateFields, publicFields, preCtor, ctor) =>
+      val own2 = own.mapConserve(_.subst)
+      val isym2 = isym.subst
       val sym2 = sym.subst
-      val parentPath2 = parentPath.map(applyPath)
-      val methods2 = methods.map(applyFunDefn)
-      val privateFields2 = privateFields.map(_.subst)
-      val publicFields2 = publicFields.map(applyTermDefinition)
+      val paramsOpt2 = paramsOpt.mapConserve(applyParamList)
+      val parentPath2 = parentPath.mapConserve(applyPath)
+      val methods2 = methods.mapConserve(applyFunDefn)
+      val privateFields2 = privateFields.mapConserve(_.subst)
+      val publicFields2 = publicFields.mapConserve(applyTermDefinition)
       val preCtor2 = applyBlock(preCtor)
       val ctor2 = applyBlock(ctor)
-      if (sym2 is sym) && (parentPath2 zip parentPath).forall(_ is _) &&
-          (methods2 zip methods).forall(_ is _) &&
-          (privateFields2 zip privateFields).forall(_ is _) &&
-          (publicFields2 zip publicFields).forall(_ is _) &&
+      if (own2 is own) && (isym2 is isym) && (sym2 is sym) &&
+          (paramsOpt2 is paramsOpt) &&
+          (parentPath2 is parentPath) &&
+          (methods2 is methods) &&
+          (privateFields2 is privateFields) &&
+          (publicFields2 is publicFields) &&
           (preCtor2 is preCtor) && (ctor2 is ctor)
-        then defn else ClsLikeDefn(sym2, k, parentPath2, methods2, privateFields2, publicFields2, preCtor2, ctor2)
+        then defn else ClsLikeDefn(own, isym2, sym2, k, paramsOpt, parentPath2, methods2, privateFields2, publicFields2, preCtor2, ctor2)
 
   def applyArg(arg: Arg): Arg =
     val val2 = applyPath(arg.value)
@@ -156,9 +163,9 @@ class BlockTransformer(subst: SymbolSubst):
     def applyParam(p: Param): Param =
       val sym2 = p.sym.subst
       if sym2 is p.sym then p else Param(p.flags, sym2, p.sign)
-    val params2 = pl.params.map(applyParam)
-    val rest2 = pl.restParam.map(applyParam)
-    if (params2 zip pl.params).forall(_ is _) && (rest2 zip pl.restParam).forall(_ is _)
+    val params2 = pl.params.mapConserve(applyParam)
+    val rest2 = pl.restParam.mapConserve(applyParam)
+    if (params2 is pl.params) && (rest2 is pl.restParam)
       then pl else ParamList(pl.flags, params2, rest2)
 
   def applyCase(cse: Case): Case = cse match
@@ -172,10 +179,10 @@ class BlockTransformer(subst: SymbolSubst):
   def applyHandler(hdr: Handler): Handler =
     val sym2 = hdr.sym.subst
     val resumeSym2 = hdr.resumeSym.subst
-    val params2 = hdr.params.map(applyParamList)
+    val params2 = hdr.params.mapConserve(applyParamList)
     val body2 = applyBlock(hdr.body)
     if (sym2 is hdr.sym) && (resumeSym2 is hdr.resumeSym) &&
-        (params2 zip hdr.params).forall(_ is _) && (body2 is hdr.body)
+        (params2 is hdr.params) && (body2 is hdr.body)
       then hdr else Handler(sym2, resumeSym2, params2, body2)
 
   def applyLam(lam: Value.Lam): Value.Lam =
@@ -184,12 +191,12 @@ class BlockTransformer(subst: SymbolSubst):
     if (params2 is lam.params) && (body2 is lam.body) then lam else Value.Lam(params2, body2)
 
   def applyTermDefinition(td: TermDefinition): TermDefinition =
-    val owner2 = td.owner.map(_.subst)
+    val owner2 = td.owner.mapConserve(_.subst)
     val sym2 = td.sym.subst
-    val params2 = td.params.map(applyParamList)
+    val params2 = td.params.mapConserve(applyParamList)
     val resSym2 = td.resSym.subst
-    if (owner2 zip td.owner).forall(_ is _) && (sym2 is td.sym) &&
-        (params2 zip td.params).forall(_ is _) && (resSym2 is td.resSym)
+    if (owner2 is td.owner) && (sym2 is td.sym) &&
+        (params2 is td.params) && (resSym2 is td.resSym)
       then td else TermDefinition(owner2, td.k, sym2, params2, td.sign, td.body, resSym2, td.flags, td.annotations)
 
 class BlockTransformerShallow(subst: SymbolSubst) extends BlockTransformer(subst):
@@ -207,9 +214,10 @@ class BlockTransformerShallow(subst: SymbolSubst) extends BlockTransformer(subst
       val res2 = applyLocal(res)
       val par2 = applyPath(par)
       val cls2 = cls.subst
-      val hdr2 = hdr.map(applyHandler)
+      val hdr2 = hdr.mapConserve(applyHandler)
       val rst2 = applyBlock(rst)
       if (l2 is l) && (res2 is res) && (par2 is par) && (cls2 is cls) &&
-          (hdr2 zip hdr).forall(_ is _) && (rst2 is rst)
+          (hdr2 is hdr) && (rst2 is rst)
         then b else HandleBlock(l2, res2, par2, cls2, hdr2, bod, rst2)
     case _ => super.applyBlock(b)
+