Make immutability the default and add opt-in mut modifier (#323)

Co-authored-by: CAG2Mark <[email protected]>

Author: LPTK

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

@@ -37,10 +37,10 @@ sealed abstract class Block extends Product with AutoLocated:
     case AssignField(lhs: Path, nme: Tree.Ident, rhs: Result, rest: Block) => lhs :: nme :: rhs :: rest :: Nil
     case AssignDynField(lhs, fld, arrayIdx, rhs, rest) => lhs :: fld :: rhs :: rest :: Nil
     case Define(FunDefn(owner, sym, params, body), rest) => sym :: (params :+ body :+ rest)
-    case Define(ValDefn(owner, k, sym, rhs), rest) => sym :: rhs :: rest :: Nil
+    case Define(ValDefn(tsym, sym, rhs), rest) => tsym :: sym :: rhs :: rest :: Nil
     case Define(ClsLikeDefn(owner, isym, sym, k, paramsOpt, aux, parentSym, methods, privFlds, pubFlds, preCtor, ctor), rest) =>
-      isym :: sym :: paramsOpt.toList ++ aux ++ parentSym.toList ++ methods.flatMap(_.subBlocks) ++ privFlds ++ pubFlds
-      ++ preCtor.subBlocks ++ ctor.subBlocks :+ rest
+      isym :: sym :: paramsOpt.toList ++ aux ++ parentSym.toList ++ methods.flatMap(_.subBlocks) ++
+        privFlds ++ pubFlds.flatMap(f => f._1 :: f._2 :: Nil) ++ preCtor.subBlocks ++ ctor.subBlocks :+ rest
     case HandleBlock(lhs, res, par, args, cls, handlers, body, rest) =>
       lhs :: res :: par :: args ++ handlers.flatMap: handler =>
         handler.sym :: handler.resumeSym :: (handler.params :+ handler.body)
@@ -328,7 +328,7 @@ sealed abstract class Defn:
   // * in the type system.
   lazy val freeVars: Set[Local] = this match
     case FunDefn(own, sym, params, body) => body.freeVars -- params.flatMap(_.paramSyms) - sym
-    case ValDefn(owner, k, sym, rhs) => rhs.freeVars
+    case ValDefn(tsym, sym, rhs) => rhs.freeVars
     case ClsLikeDefn(own, isym, sym, k, paramsOpt, auxParams, parentSym, 
         methods, privateFields, publicFields, preCtor, ctor) =>
       preCtor.freeVars
@@ -337,7 +337,7 @@ sealed abstract class Defn:
 
   lazy val freeVarsLLIR: Set[Local] = this match
     case FunDefn(own, sym, params, body) => body.freeVarsLLIR -- params.flatMap(_.paramSyms) - sym
-    case ValDefn(owner, k, sym, rhs) => rhs.freeVarsLLIR
+    case ValDefn(tsym, sym, rhs) => rhs.freeVarsLLIR
     case ClsLikeDefn(own, isym, sym, k, paramsOpt, auxParams, parentSym, 
         methods, privateFields, publicFields, preCtor, ctor) =>
       preCtor.freeVarsLLIR
@@ -353,12 +353,23 @@ final case class FunDefn(
   val innerSym = N
 
 final case class ValDefn(
-    owner: Opt[InnerSymbol],
-    k: syntax.Val,
+    tsym: TermSymbol,
     sym: BlockMemberSymbol,
     rhs: Path,
 ) extends Defn:
-  val innerSym = N
+  val innerSym = S(tsym)
+  val k = tsym.k
+  val owner: Opt[InnerSymbol] = tsym.owner
+
+object ValDefn:
+  def mk(
+      owner: Opt[InnerSymbol],
+      k: syntax.Val,
+      sym: BlockMemberSymbol,
+      rhs: Path,
+    )(using State)
+    : ValDefn =
+      ValDefn(tsym = TermSymbol(k, owner, Tree.Ident(sym.nme)), sym = sym, rhs = rhs)
 
 /*
   This explains the difference between paramsOpt, auxParams, privateFields and publicFields.
@@ -402,7 +413,7 @@ final case class ClsLikeDefn(
     parentPath: Opt[Path],
     methods: Ls[FunDefn],
     privateFields: Ls[TermSymbol],
-    publicFields: Ls[BlockMemberSymbol],
+    publicFields: Ls[BlockMemberSymbol -> TermSymbol],
     preCtor: Block,
     ctor: Block,
 ) extends Defn:
@@ -448,41 +459,41 @@ sealed abstract class Result extends AutoLocated:
 
   protected def children: List[Located] = this match
     case Call(fun, args) => fun :: args.map(_.value)
-    case Instantiate(cls, args) => cls :: args
+    case Instantiate(mut, cls, args) => cls :: args
     case Select(qual, name) => qual :: name :: Nil
     case DynSelect(qual, fld, arrayIdx) => qual :: fld :: Nil
     case Value.Ref(l) => Nil
     case Value.This(sym) => Nil
     case Value.Lit(lit) => lit :: Nil
     case Value.Lam(params, body) => params :: body :: Nil
-    case Value.Arr(elems) => elems.map(_.value)
-    case Value.Rcd(elems) => elems.map(_.value)
+    case Value.Arr(mut, elems) => elems.map(_.value)
+    case Value.Rcd(mut, elems) => elems.map(_.value)
 
   // TODO rm Lam from values and thus the need for this method
   def subBlocks: Ls[Block] = this match
     case Call(fun, args) => fun.subBlocks ::: args.flatMap(_.value.subBlocks)
-    case Instantiate(cls, args) => args.flatMap(_.subBlocks)
+    case Instantiate(mut, cls, args) => args.flatMap(_.subBlocks)
     case Select(qual, name) => qual.subBlocks
     case Value.Lam(params, body) => body :: Nil
-    case Value.Arr(elems) => elems.flatMap(_.value.subBlocks)
+    case Value.Arr(mut, elems) => elems.flatMap(_.value.subBlocks)
     case _ => Nil
 
   lazy val freeVars: Set[Local] = this match
     case Call(fun, args) => fun.freeVars ++ args.flatMap(_.value.freeVars).toSet
-    case Instantiate(cls, args) => cls.freeVars ++ args.flatMap(_.freeVars).toSet
+    case Instantiate(mut, cls, args) => cls.freeVars ++ args.flatMap(_.freeVars).toSet
     case Select(qual, name) => qual.freeVars 
     case Value.Ref(l) => Set(l)
     case Value.This(sym) => Set.empty
     case Value.Lit(lit) => Set.empty
     case Value.Lam(params, body) => body.freeVars -- params.paramSyms
-    case Value.Arr(elems) => elems.flatMap(_.value.freeVars).toSet
-    case Value.Rcd(elems) => elems.flatMap(_.value.freeVars).toSet
+    case Value.Arr(mut, elems) => elems.flatMap(_.value.freeVars).toSet
+    case Value.Rcd(mut, args) =>
+      args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVars) ++ arg.value.freeVars).toSet
     case DynSelect(qual, fld, arrayIdx) => qual.freeVars ++ fld.freeVars
-    case Value.Rcd(args) => args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVars) ++ arg.value.freeVars).toSet
-
+  
   lazy val freeVarsLLIR: Set[Local] = this match
     case Call(fun, args) => fun.freeVarsLLIR ++ args.flatMap(_.value.freeVarsLLIR).toSet
-    case Instantiate(cls, args) => cls.freeVarsLLIR ++ args.flatMap(_.freeVarsLLIR).toSet
+    case Instantiate(mut, cls, args) => cls.freeVarsLLIR ++ args.flatMap(_.freeVarsLLIR).toSet
     case Select(qual, name) => qual.freeVarsLLIR 
     case Value.Ref(l: (BuiltinSymbol | TopLevelSymbol | ClassSymbol | TermSymbol)) => Set.empty
     case Value.Ref(l: MemberSymbol[?]) => l.defn match
@@ -492,10 +503,10 @@ sealed abstract class Result extends AutoLocated:
     case Value.This(sym) => Set.empty
     case Value.Lit(lit) => Set.empty
     case Value.Lam(params, body) => body.freeVarsLLIR -- params.paramSyms
-    case Value.Arr(elems) => elems.flatMap(_.value.freeVarsLLIR).toSet
-    case Value.Rcd(elems) => elems.flatMap(_.value.freeVarsLLIR).toSet
+    case Value.Arr(mut, elems) => elems.flatMap(_.value.freeVarsLLIR).toSet
+    case Value.Rcd(mut, args) =>
+      args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVarsLLIR) ++ arg.value.freeVarsLLIR).toSet
     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
 
 // type Local = LocalSymbol
 type Local = Symbol
@@ -506,7 +517,7 @@ type Local = Symbol
  * after handler is lowered does not have any effect on the code generation. */
 case class Call(fun: Path, args: Ls[Arg])(val isMlsFun: Bool, val mayRaiseEffects: Bool) extends Result
 
-case class Instantiate(cls: Path, args: Ls[Path]) extends Result
+case class Instantiate(mut: Bool, cls: Path, args: Ls[Path]) extends Result
 
 sealed abstract class Path extends TrivialResult:
   def selN(id: Tree.Ident): Path = Select(this, id)(N)
@@ -524,8 +535,8 @@ enum Value extends Path:
   case This(sym: InnerSymbol) // TODO rm – just use Ref
   case Lit(lit: Literal)
   case Lam(params: ParamList, body: Block)
-  case Arr(elems: Ls[Arg])
-  case Rcd(elems: Ls[RcdArg])
+  case Arr(mut: Bool, elems: Ls[Arg])
+  case Rcd(mut: Bool, elems: Ls[RcdArg])
 
 case class Arg(spread: Opt[Bool], value: Path)
 

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

@@ -100,10 +100,10 @@ class BlockTransformer(subst: SymbolSubst):
       val fun2 = applyPath(fun)
       val args2 = args.mapConserve(applyArg)
       if (fun2 is fun) && (args2 is args) then r else Call(fun2, args2)(r.isMlsFun, r.mayRaiseEffects)
-    case Instantiate(cls, args) =>
+    case Instantiate(mut, cls, args) =>
       val cls2 = applyPath(cls)
       val args2 = args.mapConserve(applyPath)
-      if (cls2 is cls) && (args2 is args) then r else Instantiate(cls2, args2)
+      if (cls2 is cls) && (args2 is args) then r else Instantiate(mut, cls2, args2)
     case p: Path => applyPath(p)
 
   def applyPath(p: Path): Path = p match
@@ -126,16 +126,16 @@ class BlockTransformer(subst: SymbolSubst):
       if (sym2 is sym) then v else Value.This(sym2)
     case Value.Lit(lit) => v
     case v @ Value.Lam(params, body) => applyLam(v)
-    case Value.Arr(elems) =>
+    case Value.Arr(mut, elems) =>
       val elems2 = elems.mapConserve(applyArg)
-      if (elems2 is elems) then v else Value.Arr(elems2)
-    case Value.Rcd(fields) =>
+      if (elems2 is elems) then v else Value.Arr(mut, elems2)
+    case Value.Rcd(mut, fields) =>
       val fields2 = fields.mapConserve:
         case arg @ RcdArg(idx, v) =>
           val idx2 = idx.mapConserve(applyPath)
           val v2 = applyPath(v)
           if (idx2 is idx) && (v2 is v) then arg else RcdArg(idx2, v2)
-      if fields2 is fields then v else Value.Rcd(fields2)
+      if fields2 is fields then v else Value.Rcd(mut, fields2)
 
   def applyLocal(sym: Local): Local = sym.subst
 
@@ -148,12 +148,12 @@ class BlockTransformer(subst: SymbolSubst):
       then fun else FunDefn(own2, sym2, params2, body2)
 
   def applyValDefn(defn: ValDefn): ValDefn =
-    val ValDefn(owner, k, sym, rhs) = defn
-    val owner2 = owner.mapConserve(_.subst)
+    val ValDefn(tsym, sym, rhs) = defn
+    val tsym2 = tsym.subst
     val sym2 = sym.subst
     val rhs2 = applyPath(rhs)
-    if (owner2 is owner) && (sym2 is sym) && (rhs2 is rhs)
-      then defn else ValDefn(owner2, k, sym2, rhs2)
+    if (tsym2 is tsym) && (sym2 is sym) && (rhs2 is rhs)
+      then defn else ValDefn(tsym2, sym2, rhs2)
 
   def applyDefn(defn: Defn): Defn = defn match
     case defn: FunDefn => applyFunDefn(defn)
@@ -168,7 +168,7 @@ class BlockTransformer(subst: SymbolSubst):
       val parentPath2 = parentPath.mapConserve(applyPath)
       val methods2 = methods.mapConserve(applyFunDefn)
       val privateFields2 = privateFields.mapConserve(_.subst)
-      val publicFields2 = publicFields.mapConserve(_.subst)
+      val publicFields2 = publicFields.mapConserve(f => f._1.subst -> f._2.subst)
       val preCtor2 = applySubBlock(preCtor)
       val ctor2 = applySubBlock(ctor)
       if (own2 is own) && (isym2 is isym) && (sym2 is sym) &&

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

@@ -54,7 +54,7 @@ class BlockTraverser:
 
   def applyResult(r: Result): Unit = r match
     case r @ Call(fun, args) => applyPath(fun); args.foreach(applyArg)
-    case Instantiate(cls, args) =>; applyPath(cls); args.foreach(applyPath)
+    case Instantiate(mut, cls, args) =>; applyPath(cls); args.foreach(applyPath)
     case p: Path => applyPath(p)
 
   def applyPath(p: Path): Unit = p match
@@ -69,8 +69,8 @@ class BlockTraverser:
     case Value.This(sym) => sym.traverse
     case Value.Lit(lit) => ()
     case v @ Value.Lam(params, body) => applyLam(v)
-    case Value.Arr(elems) => elems.foreach(applyArg)
-    case Value.Rcd(fields) => fields.foreach:
+    case Value.Arr(mut, elems) => elems.foreach(applyArg)
+    case Value.Rcd(mut, fields) => fields.foreach:
       case RcdArg(idx, value) => idx.foreach(applyPath); applyPath(value)
 
   def applyLocal(sym: Local): Unit = sym.traverse
@@ -82,8 +82,8 @@ class BlockTraverser:
     applySubBlock(fun.body)
 
   def applyValDefn(defn: ValDefn): Unit =
-    val ValDefn(owner, k, sym, rhs) = defn
-    owner.foreach(_.traverse); sym.traverse; applyPath(rhs)
+    val ValDefn(tsym, sym, rhs) = defn
+    tsym.owner.foreach(_.traverse); sym.traverse; applyPath(rhs)
 
   def applyDefn(defn: Defn): Unit = defn match
     case defn: FunDefn => applyFunDefn(defn)
@@ -98,7 +98,8 @@ class BlockTraverser:
       parentPath.foreach(applyPath)
       methods.foreach(applyFunDefn)
       privateFields.foreach(_.traverse)
-      publicFields.foreach(_.traverse)
+      publicFields.foreach: f =>
+        f._1.traverse; f._2.traverse
       applySubBlock(preCtor)
       applySubBlock(ctor)
 

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

@@ -86,7 +86,8 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     HandlerCtx(false, false, contNme, ctorThis, h.debugInfo.copy(debugNme), state =>
       blockBuilder
         .assignFieldN(state.res.asPath.contTrace.last, nextIdent, Instantiate(
-          state.cls.selN(Tree.Ident("class")),
+          mut = true,
+          state.cls,
           Value.Lit(Tree.IntLit(state.uid)) :: Nil))
         .assignFieldN(state.res.asPath.contTrace, lastIdent, state.res.asPath.contTrace.last.next)
         .ret(state.res.asPath))
@@ -102,7 +103,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
   private def freshTmp(dbgNme: Str = "tmp") = new TempSymbol(N, dbgNme)
 
   private def rtThrowMsg(msg: Str) = Throw(
-    Instantiate(State.globalThisSymbol.asPath.selN(Tree.Ident("Error")),
+    Instantiate(mut = false, State.globalThisSymbol.asPath.selN(Tree.Ident("Error")),
     Value.Lit(Tree.StrLit(msg)) :: Nil)
   )
 
@@ -312,22 +313,22 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
   private def createGetLocalsFn(b: Block, extraLocals: Set[Local])(using h: HandlerCtx) =
     val locals = (b.userDefinedVars ++ extraLocals) -- h.debugInfo.inScopeLocals
     val localsInfo = locals.toList.sortBy(_.uid).map: s =>
-      FlowSymbol(s.nme) -> Instantiate(localVarInfoPath,
+      FlowSymbol(s.nme) -> Instantiate(mut = true, localVarInfoPath,
         Value.Lit(Tree.StrLit(s.nme)) :: s.asPath :: Nil
       )
     val startSym = FlowSymbol("prev")
     val thisInfo = FlowSymbol("thisInfo")
 
     val body = blockBuilder
       .assign(startSym, h.debugInfo.prevLocalsFn match
-          case None => Value.Arr(Nil)
+          case None => Value.Arr(mut = true, Nil)
           case Some(value) => PureCall(value, Nil)
         )
       .foldLeft(localsInfo):
         case (acc, (sym, res)) => acc.assign(sym, res)
-      .assign(thisInfo, Instantiate(fnLocalsPath,
+      .assign(thisInfo, Instantiate(mut = true, fnLocalsPath,
           Value.Lit(Tree.StrLit(h.debugInfo.debugNme))
-            :: Value.Arr(localsInfo.map(v => v._1.asPath.asArg))
+            :: Value.Arr(mut = false, localsInfo.map(v => v._1.asPath.asArg))
             :: Nil
         ))
       .assign(TempSymbol(N, ""), Call(startSym.asPath.selSN("push"), thisInfo.asPath.asArg :: Nil)(false, false))
@@ -374,10 +375,10 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
           val args2 = args.mapConserve(applyArg)
           val c2 = if (fun2 is fun) && (args2 is args) then c else Call(fun2, args2)(c.isMlsFun, c.mayRaiseEffects)
           ResultPlaceholder(lhs, freshId(), c2, applyBlock(rest))
-        case Assign(lhs, c @ Instantiate(cls, args), rest) =>
+        case Assign(lhs, c @ Instantiate(mut, cls, args), rest) =>
           val cls2 = applyPath(cls)
           val args2 = args.mapConserve(applyPath)
-          val c2 = if (cls2 is cls) && (args2 is args) then c else Instantiate(cls2, args2)
+          val c2 = if (cls2 is cls) && (args2 is args) then c else Instantiate(mut, cls2, args2)
           ResultPlaceholder(lhs, freshId(), c2, applyBlock(rest))
         case _ => super.applyBlock(b)
       override def applyResult2(r: Result)(k: Result => Block): Block = r match
@@ -387,11 +388,11 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
           val args2 = args.mapConserve(applyArg)
           val c2 = if (fun2 is fun) && (args2 is args) then c else Call(fun2, args2)(c.isMlsFun, c.mayRaiseEffects)
           ResultPlaceholder(res, freshId(), c2, k(Value.Ref(res)))
-        case c @ Instantiate(cls, args) =>
+        case c @ Instantiate(mut, cls, args) =>
           val res = freshTmp("res")
           val cls2 = applyPath(cls)
           val args2 = args.mapConserve(applyPath)
-          val c2 = if (cls2 is cls) && (args2 is args) then c else Instantiate(cls2, args2)
+          val c2 = if (cls2 is cls) && (args2 is args) then c else Instantiate(mut, cls2, args2)
           ResultPlaceholder(res, freshId(), c2, k(Value.Ref(res)))
         case r => super.applyResult2(r)(k)
       override def applyPath(p: Path): Path = p match
@@ -454,7 +455,8 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
     val handlerBody = translateBlock(h.body, Set.empty, HandlerCtx(false, true,
       s"Cont$$handleBlock$$${symToStr(h.lhs)}$$", N, handlerCtx.debugInfo.copy(debugNme = s"‹handler body of ${h.lhs.nme}›"), state => blockBuilder
-        .assignFieldN(state.res.asPath.contTrace.last, nextIdent, PureCall(state.cls, Value.Lit(Tree.IntLit(state.uid)) :: Nil))
+        .assignFieldN(state.res.asPath.contTrace.last, nextIdent,
+          Instantiate(mut = true, state.cls, Value.Lit(Tree.IntLit(state.uid)) :: Nil))
         .ret(PureCall(paths.handleBlockImplPath, state.res.asPath :: h.lhs.asPath :: Nil))))
 
     val handlerMtds = h.handlers.map: handler =>
@@ -480,7 +482,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
     val body = blockBuilder
       .define(clsDefn)
-      .assign(h.lhs, Instantiate(Value.Ref(clsDefn.sym), Nil))
+      .assign(h.lhs, Instantiate(mut = true, Value.Ref(clsDefn.sym), Nil))
       .rest(handlerBody)
 
     val defn = FunDefn(
@@ -594,7 +596,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
       val localsRes = h.debugInfo.prevLocalsFn match
         case Some(value) => PureCall(value, Nil)
-        case None => Value.Arr(Nil)
+        case None => Value.Arr(mut = true, Nil)
 
       val getLocalsFnDef = FunDefn(
         S(clsSym),
@@ -623,12 +625,12 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
       clsSym,
       BlockMemberSymbol(clsSym.nme, Nil),
       syntax.Cls,
-      S(PlainParamList({
-        val p = Param(FldFlags.empty.copy(value = true), pcVar, N, Modulefulness.none)
+      N,
+      PlainParamList({
+        val p = Param(FldFlags.empty.copy(isVal = true), pcVar, N, Modulefulness.none)
         pcVar.decl = S(p)
         p
-      } :: Nil)),
-      Nil,
+      } :: Nil) :: Nil,
       S(paths.contClsPath),
       resumeFnDef :: debugMtds,
       Nil,