Add preliminary support for inheritance and refined new

Author: LPTK

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

@@ -502,7 +502,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       case t @ Term.App(lhs, Term.Tup(rhs)) =>
         val (funTy, lhsEff) = typeCheck(lhs)
         app((funTy, lhsEff), rhs, t)
-      case Term.New(cls, args) =>
+      case Term.New(cls, args, N) =>
         cls.symbol.flatMap(_.asCls.flatMap(_.defn)) match
         case S(clsDfn: ClassDef.Parameterized) =>
           require(clsDfn.paramsOpt.forall(_.restParam.isEmpty))

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

@@ -231,6 +231,8 @@ final case class ClsLikeDefn(
     preCtor: Block,
     ctor: Block,
 ) extends Defn:
+  publicFields.foreach: f =>
+    require(f.owner.contains(isym))
   val innerSym = S(isym)
 
 final case class Handler(

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

@@ -417,7 +417,7 @@ class HandlerLowering(using TL, Raise, Elaborator.State, Elaborator.Ctx):
 
   private def genContClass(b: Block)(using HandlerCtx): Opt[ClsLikeDefn] =
     val clsSym = ClassSymbol(
-      Tree.TypeDef(syntax.Cls, Tree.Error(), N, N),
+      Tree.DummyTypeDef(syntax.Cls),
       Tree.Ident("Cont$")
     )
 

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

@@ -164,6 +164,7 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
             msg"Unexpected arguments for builtin symbol '${sym.nme}'" -> arg.toLoc :: Nil, S(arg),
             source = Diagnostic.Source.Compilation)
         End("error")
+    case st.TyApp(f, ts) => term(f)(k) // * Type arguments are erased
     case st.App(f, arg) =>
       val isMlsFun = f.symbol.fold(f.isInstanceOf[st.Lam]):
         case _: sem.BuiltinSymbol => true
@@ -200,7 +201,7 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
           conclude(Select(p, nme)(sel.sym))
       case _ => subTerm(f)(conclude)
 
-    case st.Blk((h @ Handle(lhs, rhs, args, cls, defs)) :: stmts, res) =>
+    case st.Blk((h @ Handle(lhs, rhs, as, cls, defs)) :: stmts, res) =>
       if !lowerHandlers then
         raise(ErrorReport(
           msg"Effect handlers are not enabled" ->
@@ -218,14 +219,10 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
       }.collect{ case Some(v) => v }
       val resSym = TempSymbol(S(t))
       subTerm(rhs): par =>
-        def rec(as: Ls[st], asr: Ls[Path]): Block = as match
-          case Nil => HandleBlock(lhs, resSym, par, asr.reverse, cls, handlers,
+        subTerms(as): asr =>
+          HandleBlock(lhs, resSym, par, asr, cls, handlers,
             term_nonTail(st.Blk(stmts, res))(HandleBlockReturn(_)),
             k(Value.Ref(resSym)))
-          case a :: as =>
-            subTerm_nonTail(a): ar =>
-              rec(as, ar :: asr)
-        rec(args, Nil)
 
     case st.Blk(Nil, res) => term(res)(k)
     case st.Blk((t: sem.Term) :: stats, res) =>
@@ -255,33 +252,25 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
         term(st.Blk(stats, res))(k)
       case cls: ClassLikeDef =>
         reportAnnotations(cls, cls.extraAnnotations)
-        val bodBlk = cls.body.blk
-        val (mtds, rest1) = bodBlk.stats.partitionMap:
-          case td: TermDefinition if td.k is syntax.Fun => L(td)
-          case s => R(s)
-        val (privateFlds, rest2) = rest1.partitionMap:
-          case decl @ LetDecl(sym: TermSymbol, annotations) =>
-            reportAnnotations(decl, annotations)
-            L(sym)
-          case s => R(s)
-        val publicFlds = rest2.collect:
-          case td @ TermDefinition(k = (_: syntax.Val)) => td
-        Define(ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, N,
-            mtds.flatMap: td =>
-              td.body.map: bod =>
-                val (paramLists, bodyBlock) = setupFunctionDef(td.params, bod, S(td.sym.nme))
-                FunDefn(td.owner, td.sym, paramLists, bodyBlock)
-            ,
-            privateFlds,
-            publicFlds,
-            End(),
-            term_nonTail(Blk(rest2, bodBlk.res))(ImplctRet)
-              // * This is just a minor improvement to get `constructor() {}` instead of `constructor() { null }`
-              .mapTail:
-                case Return(Value.Lit(syntax.Tree.UnitLit(true)), true) => End()
-                case t => t
-          ),
-        term_nonTail(st.Blk(stats, res))(k))
+        val (mtds, publicFlds, privateFlds, ctor) = gatherMembers(cls.body)
+        cls.ext match
+        case N =>
+          Define(
+            ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, N,
+              mtds, privateFlds, publicFlds, End(), ctor),
+            term_nonTail(st.Blk(stats, res))(k)
+          )
+        case S(ext) =>
+          assert(k isnt syntax.Mod) // modules can't extend things and can't have super calls
+          subTerm(ext.cls): clsp =>
+            val pctor = // TODO dedup with `New` case
+              args(ext.args): args =>
+                Return(Call(Value.Ref(State.builtinOpsMap("super")), args)(true, true), implct = true)
+            Define(
+              ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, S(clsp),
+                mtds, privateFlds, publicFlds, pctor, ctor),
+              term_nonTail(st.Blk(stats, res))(k)
+            )
       case _ =>
         // TODO handle
         term(st.Blk(stats, res))(k)
@@ -463,15 +452,22 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
         subTerm_nonTail(fld): f =>
           k(DynSelect(p, f, ai))
 
-        
-    case New(cls, as) =>
+      
+    case New(cls, as, N) =>
       subTerm(cls): sr =>
-        def rec(as: Ls[st], asr: Ls[Path]): Block = as match
-          case Nil => k(Instantiate(sr, asr.reverse))
-          case a :: as =>
-            subTerm_nonTail(a): ar =>
-              rec(as, ar :: asr)
-        rec(as, Nil)
+        subTerms(as): asr =>
+          k(Instantiate(sr, asr))
+        
+    case New(cls, as, S((isym, rft))) =>
+      subTerm(cls): clsp =>
+        val sym = new BlockMemberSymbol(isym.name, Nil)
+        val (mtds, publicFlds, privateFlds, ctor) = gatherMembers(rft)
+        val pctor =
+          args(as): args =>
+            Return(Call(Value.Ref(State.builtinOpsMap("super")), args)(true, true), implct = true)
+        val clsDef = ClsLikeDefn(N, isym, sym, syntax.Cls, N, S(clsp),
+          mtds, privateFlds, publicFlds, pctor, ctor)
+        Define(clsDef, term_nonTail(New(sym.ref(), Nil, N))(k))
 
     case Try(sub, finallyDo) =>
       val l = new TempSymbol(S(sub))
@@ -488,12 +484,8 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
       Assign(reg, Instantiate(Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Region"))(N), Nil),
         term_nonTail(body)(k))
     case RegRef(reg, value) =>
-      def rec(as: Ls[st], asr: Ls[Path]): Block = as match
-        case Nil => k(Instantiate(Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Ref"))(N), asr.reverse))
-        case a :: as =>
-          subTerm_nonTail(a): ar =>
-            rec(as, ar :: asr)
-      rec(reg :: value :: Nil, Nil)
+      subTerms(reg :: value :: Nil): args =>
+        k(Instantiate(Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Ref"))(N), args))
     case Deref(ref) =>
       subTerm(ref): r =>
         k(Select(r, Tree.Ident("value"))(N))
@@ -520,6 +512,36 @@ class Lowering(lowerHandlers: Bool, stackLimit: Option[Int])(using TL, Raise, St
     // case _ =>
     //   subTerm(t)(k)
 
+  def gatherMembers(clsBody: ObjBody)(using Subst): (Ls[FunDefn], Ls[TermDefinition], Ls[TermSymbol], Block) =
+    val mtds = clsBody.methods
+      .flatMap: td =>
+        td.body.map: bod =>
+          val (paramLists, bodyBlock) = setupFunctionDef(td.params, bod, S(td.sym.nme))
+          FunDefn(td.owner, td.sym, paramLists, bodyBlock)
+    val publicFlds = clsBody.publicFlds
+    val privateFlds = clsBody.nonMethods.collect:
+      case decl @ LetDecl(sym: TermSymbol, annotations) =>
+        reportAnnotations(decl, annotations)
+        sym
+    val ctor =
+      term_nonTail(Blk(clsBody.nonMethods, clsBody.blk.res))(ImplctRet)
+        // * This is just a minor improvement to get `constructor() {}` instead of `constructor() { null }`
+        .mapTail:
+          case Return(Value.Lit(syntax.Tree.UnitLit(true)), true) => End()
+          case t => t
+    (mtds, publicFlds, privateFlds, ctor)
+  
+  inline def args(ts: Ls[st])(k: Ls[Arg] => Block)(using Subst): Block =
+    subTerms(ts)(asr => k(asr.map(Arg(false, _))))
+  inline def subTerms(ts: Ls[st])(k: Ls[Path] => Block)(using Subst): Block =
+    // @tailrec // TODO
+    def rec(as: Ls[st], asr: Ls[Path]): Block = as match
+      case Nil => k(asr.reverse)
+      case a :: as =>
+        subTerm_nonTail(a): ar =>
+          rec(as, ar :: asr)
+    rec(ts, Nil)
+  
   def subTerm_nonTail(t: st, inStmtPos: Bool = false)(k: Path => Block)(using Subst): Block =
     subTerm(t: st, inStmtPos: Bool)(k)
 
@@ -591,7 +613,7 @@ trait LoweringSelSanityChecks
               Pattern.Lit(syntax.Tree.UnitLit(false)),
               Split.Else(
                 Term.Throw(Term.New(SynthSel(State.globalThisSymbol.ref(), Tree.Ident("Error"))(N),
-                  Term.Lit(syntax.Tree.StrLit(s"Access to required field '${nme.name}' yielded 'undefined'")) :: Nil)
+                  Term.Lit(syntax.Tree.StrLit(s"Access to required field '${nme.name}' yielded 'undefined'")) :: Nil, N)
                 ))),
             Split.Else(selRes.ref()))
         Assign(

hkmc2/shared/src/main/scala/hkmc2/codegen/js/JSBuilder.scala

@@ -136,15 +136,18 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case Value.Arr(es) if es.isEmpty => doc"[]"
     case Value.Arr(es) =>
       doc"[ #{  # ${es.map(argument).mkDocument(doc", # ")} #}  # ]"
-  def returningTerm(t: Block)(using Raise, Scope): Document = t match
+  
+  def returningTerm(t: Block, endSemi: Bool)(using Raise, Scope): Document =
+    def mkSemi = if endSemi then ";" else ""
+    t match
     case _: (HandleBlockReturn | HandleBlock) =>
       errStmt(msg"This code requires effect handler instrumentation but was compiled without it.")
     case Assign(l, r, rst) =>
-      doc" # ${getVar(l)} = ${result(r)};${returningTerm(rst)}"
+      doc" # ${getVar(l)} = ${result(r)};${returningTerm(rst, endSemi)}"
     case AssignField(p, n, r, rst) =>
-      doc" # ${result(p)}.${n.name} = ${result(r)};${returningTerm(rst)}"
+      doc" # ${result(p)}.${n.name} = ${result(r)};${returningTerm(rst, endSemi)}"
     case AssignDynField(p, f, ai, r, rst) =>
-      doc" # ${result(p)}[${result(f)}] = ${result(r)};${returningTerm(rst)}"
+      doc" # ${result(p)}[${result(f)}] = ${result(r)};${returningTerm(rst, endSemi)}"
     case Define(defn, rst) =>
       def mkThis(sym: InnerSymbol): Document =
         result(Value.This(sym))
@@ -153,9 +156,9 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
         val sym = defn.sym
         own match
         case N =>
-          doc"${getVar(sym)} = ${result(p)};${returningTerm(rst)}"
+          doc"${getVar(sym)} = ${result(p)};${returningTerm(rst, endSemi)}"
         case S(owner) =>
-          doc"${mkThis(owner)}.${sym.nme} = ${result(p)};${returningTerm(rst)}"
+          doc"${mkThis(owner)}.${sym.nme} = ${result(p)};${returningTerm(rst, endSemi)}"
       case defn: (FunDefn | ClsLikeDefn) =>
         val outerScope = scope
         val (thisProxy, res) = scope.nestRebindThis(
@@ -183,16 +186,18 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                   val nme = scp.allocateName(fld)
                   doc" # $mtdPrefix#$nme;"
                 .mkDocument(doc"")
-            val preCtorCode = ctorParams.foldLeft(body(preCtor)):
+            val preCtorCode = ctorParams.foldLeft(body(preCtor, endSemi = true)):
               case (acc, (sym, nme)) =>
                 doc"$acc # this.${sym.name} = $nme;"
-            val ctorCode = doc"$preCtorCode${body(ctor)}"
+            val ctorCode = doc"$preCtorCode${body(ctor, endSemi = false)}"
             val ctorOrStatic = if isModule
               then doc"static"
               else doc"constructor(${
                   ctorParams.unzip._2.mkDocument(", ")
                 })"
-            val clsJS = doc"class ${scope.lookup_!(isym)}${par.map(p => s" extends ${result(p)}").getOrElse("")} { #{ ${
+            val clsJS = doc"class ${scope.lookup_!(isym)}${
+                par.map(p => s" extends ${result(p)}").getOrElse("")
+              } { #{ ${
                 privs
               } # $ctorOrStatic ${ braced(ctorCode) }${
                 mtds.map: 
@@ -203,7 +208,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                     val (params, bodyDoc) = setupFunction(some(td.sym.nme), ps, result)
                     doc" # $mtdPrefix${td.sym.nme}($params) ${ braced(bodyDoc) }"
                   case td @ FunDefn(_, _, Nil, bod) =>
-                    doc" # ${mtdPrefix}get ${td.sym.nme}() ${ braced(body(bod)) }"
+                    doc" # ${mtdPrefix}get ${td.sym.nme}() ${ braced(body(bod, endSemi = true)) }"
                 .mkDocument(" ")
               }${
                 if mtds.exists(_.sym.nme == "toString")
@@ -255,17 +260,17 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
         thisProxy match
           case S(proxy) if !scope.thisProxyDefined =>
             scope.thisProxyDefined = true
-            doc"const $proxy = this; # $res${returningTerm(rst)}"
-          case _ => doc"$res${returningTerm(rst)}"
+            doc"const $proxy = this; # $res${returningTerm(rst, endSemi)}"
+          case _ => doc"$res${returningTerm(rst, endSemi = false)}"
       doc" # $resJS"
-    case Return(res, true) => doc" # ${result(res)}"
-    case Return(res, false) => doc" # return ${result(res)};"
+    case Return(res, true) => doc" # ${result(res)}${mkSemi}"
+    case Return(res, false) => doc" # return ${result(res)}${mkSemi}"
 
     case Match(scrut, Nil, els, rest) =>
       val e = els match
-      case S(el) => returningTerm(el)
+      case S(el) => returningTerm(el, endSemi = true)
       case N => doc""
-      e :: returningTerm(rest)
+      e :: returningTerm(rest, endSemi)
     case Match(scrut, hd :: tl, els, rest) =>
       val sd = result(scrut)
       def cond(cse: Case) = cse match
@@ -280,16 +285,17 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
           case Elaborator.ctx.Builtins.Int => doc"globalThis.Number.isInteger($sd)"
           case _ => doc"$sd instanceof ${result(pth)}"
         case Case.Tup(len, inf) => doc"globalThis.Array.isArray($sd) && $sd.length ${if inf then ">=" else "==="} ${len}"
-      val h = doc" # if (${ cond(hd._1) }) ${ braced(returningTerm(hd._2)) }"
-      val t = tl.foldLeft(h)((acc, arm) => acc :: doc" else if (${ cond(arm._1) }) ${ braced(returningTerm(arm._2)) }")
+      val h = doc" # if (${ cond(hd._1) }) ${ braced(returningTerm(hd._2, endSemi = false)) }"
+      val t = tl.foldLeft(h)((acc, arm) =>
+        acc :: doc" else if (${ cond(arm._1) }) ${ braced(returningTerm(arm._2, endSemi = false)) }")
       val e = els match
       case S(el) =>
-        doc" else ${ braced(returningTerm(el)) }"
+        doc" else ${ braced(returningTerm(el, endSemi = false)) }"
       case N  => doc""
-      t :: e :: returningTerm(rest)
+      t :: e :: returningTerm(rest, endSemi)
 
     case Begin(sub, thn) =>
-      doc"${returningTerm(sub)}${returningTerm(thn)}"
+      doc"${returningTerm(sub, endSemi = true)}${returningTerm(thn, endSemi)}"
 
     case End("") => doc""
     case End(msg) =>
@@ -307,12 +313,14 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case Label(lbl, bod, rst) =>
       scope.allocateName(lbl)
       doc" # ${getVar(lbl)}: while (true) { #{ ${
-        returningTerm(bod)
-      } # break; #}  # }${returningTerm(rst)}"
+        returningTerm(bod, endSemi = false)
+      } # break; #}  # }${returningTerm(rst, endSemi)}"
 
     case TryBlock(sub, fin, rst) =>
-      doc" # try ${ braced(returningTerm(sub)) } finally ${ braced(returningTerm(fin)) } # ${
-        returningTerm(rst).stripBreaks}"
+      doc" # try ${ braced(returningTerm(sub, endSemi = false)) } finally ${
+        braced(returningTerm(fin, endSemi = false))
+      } # ${
+        returningTerm(rst, endSemi).stripBreaks}"
 
     // case _ => ???
 
@@ -361,7 +369,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
         then "./" + os.Path(path).relativeTo(wd).toString
         else path
       doc"""import ${getVar(i._1)} from "${relPath}";"""
-    imps.mkDocument(doc" # ") :/: block(p.main).stripBreaks :: (
+    imps.mkDocument(doc" # ") :/: block(p.main, endSemi = false).stripBreaks :: (
       exprt match
         case S(sym) => doc"\nlet ${sym.nme} = ${scope.lookup_!(sym)}; export default ${sym.nme};\n"
         case N => doc""
@@ -375,7 +383,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       val v = doc"this.${getVar(i._1)}"
       doc"""$v = await import("${i._2.toString
         }"); # if ($v.default !== undefined) $v = $v.default;"""
-    blockPreamble(p.main) -> (imps.mkDocument(doc" # ") :/: returningTerm(p.main).stripBreaks)
+    blockPreamble(p.main) -> (imps.mkDocument(doc" # ") :/: returningTerm(p.main, endSemi = false).stripBreaks)
 
   def blockPreamble(t: Block)(using Raise, Scope): Document =
     // TODO document: mutable var assnts require the lookup
@@ -387,11 +395,11 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       .toList.mkDocument(", ")
       :: doc";"
 
-  def block(t: Block)(using Raise, Scope): Document =
-    blockPreamble(t) :: returningTerm(t)
+  def block(t: Block, endSemi: Bool)(using Raise, Scope): Document =
+    blockPreamble(t) :: returningTerm(t, endSemi)
 
-  def body(t: Block)(using Raise, Scope): Document = scope.nest givenIn:
-    block(t)
+  def body(t: Block, endSemi: Bool)(using Raise, Scope): Document = scope.nest givenIn:
+    block(t, endSemi)
 
   def braced(t: Document)(using Raise, Scope): Document =
     if t.isEmpty then
@@ -404,7 +412,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     val paramsList = params.params.map(p => scope.allocateName(p.sym))
       .++(params.restParam.map(p => "..." + scope.allocateName(p.sym)))
       .mkDocument(", ")
-    (paramsList, this.body(body))
+    (paramsList, this.body(body, endSemi = false))
 
 
 
@@ -523,7 +531,7 @@ trait JSBuilderArgNumSanityChecks
       val restAssign = paramRest match
         case N => doc""
         case S(p) => doc"\nlet $p = globalThis.Predef.tupleSlice($paramsStr, ${params.paramCountLB}, 0);"
-      (doc"...$paramsStr", doc"$checkArgsNum$paramsAssign$restAssign${this.body(body)}")
+      (doc"...$paramsStr", doc"$checkArgsNum$paramsAssign$restAssign${this.body(body, endSemi = false)}")
     else
       super.setupFunction(name, params, body)