Remove useless uid parameter and stop printing uids all the time

Author: LPTK

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

@@ -67,7 +67,6 @@ end BbCtx
 
 
 class BBTyper(using elState: Elaborator.State, tl: TL):
-  import elState.nextUid
   import tl.{trace, log}
 
   private val infVarState = new InfVarUid.State()

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

@@ -71,7 +71,7 @@ class Lowering(using TL, Raise, Elaborator.State):
           case sem.Fld(sem.FldFlags(false, false, false, true), value, N) => value
           case sem.Fld(flags, value, asc) =>
             TODO("Other argument forms")
-        val l = new TempSymbol(summon[Elaborator.State].nextUid, S(t))
+        val l = new TempSymbol(S(t))
         subTerm(f): fr =>
           def rec(as: Ls[st], asr: Ls[Path]): Block = as match
             case Nil => k(Call(fr, asr.reverse))
@@ -182,7 +182,7 @@ class Lowering(using TL, Raise, Elaborator.State):
             term(els)(k)
           )
       case _ =>
-        val l = new TempSymbol(summon[Elaborator.State].nextUid, S(t))
+        val l = new TempSymbol(S(t))
         subTerm(scrut): sr =>
             Match(sr, Case.Lit(tru) -> subTerm(thn)(r => Assign(l, r, End())) :: Nil,
               elseBranch.map(els => subTerm(els)(r => Assign(l, r, End()))),
@@ -202,10 +202,10 @@ class Lowering(using TL, Raise, Elaborator.State):
       var usesResTmp = false
       lazy val l =
         usesResTmp = true
-        new TempSymbol(summon[Elaborator.State].nextUid, S(t))
+        new TempSymbol(S(t))
 
       lazy val lbl =
-        new TempSymbol(summon[Elaborator.State].nextUid, S(t))
+        new TempSymbol(S(t))
 
       def go(split: Split, topLevel: Bool)(using Subst): Block = split match
         case Split.Let(sym, trm, tl) =>
@@ -234,7 +234,7 @@ class Lowering(using TL, Raise, Elaborator.State):
                       // mkMatch(Case.Cls(cls, st) -> go(tail, topLevel = false))
                       Case.Cls(cls, st) -> go(tail, topLevel = false)
                     case (param, arg) :: args =>
-                      // summon[Subst].+(arg -> Value.Ref(new TempSymbol(summon[Elaborator.State].nextUid, N)))
+                      // summon[Subst].+(arg -> Value.Ref(new TempSymbol(N)))
                       // Assign(arg, Select(sr, Tree.Ident("head")), mkArgs(args))
 
                       val (cse, blk) = mkArgs(args)
@@ -288,7 +288,7 @@ class Lowering(using TL, Raise, Elaborator.State):
         rec(as, Nil)
 
     case Try(sub, finallyDo) =>
-      val l = new TempSymbol(summon[Elaborator.State].nextUid, S(sub))
+      val l = new TempSymbol(S(sub))
       TryBlock(
         term(sub)(p => Assign(l, p, End())),
         term(finallyDo)(_ => End()),
@@ -305,7 +305,7 @@ class Lowering(using TL, Raise, Elaborator.State):
       case v: Value => k(v)
       case p: Path => k(p)
       case r =>
-        val l = new TempSymbol(summon[Elaborator.State].nextUid, N)
+        val l = new TempSymbol(N)
         Assign(l, r, k(l |> Value.Ref.apply))
 
 

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

@@ -188,7 +188,7 @@ class JSBuilder extends CodeBuilder:
                 }; }"""
               } #}  # }"
             if (clsDefn.kind is syntax.Mod) || (clsDefn.kind is syntax.Obj) then
-              val clsTmp = summon[Scope].allocateName(new semantics.TempSymbol(0/*TODO rm this useless param*/, N, sym.nme+"$"+"class"))
+              val clsTmp = summon[Scope].allocateName(new semantics.TempSymbol(N, sym.nme+"$"+"class"))
               clsDefn.owner match
               case S(owner) =>
                 assert(clsDefn.paramsOpt.isEmpty)
@@ -427,7 +427,7 @@ end JSBuilder
 
 trait JSBuilderSanityChecks(instrument: Bool) extends JSBuilder:
 
-  val functionParamVarargSymbol = semantics.TempSymbol(0, N, "args")
+  val functionParamVarargSymbol = semantics.TempSymbol(N, "args")
 
   override def setupFunction(name: Option[Str], params: List[semantics.Param], body: Block)(using Raise, Scope): (Document, Document) =
     if instrument then

hkmc2/shared/src/main/scala/hkmc2/semantics/Desugarer.scala

@@ -35,7 +35,6 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
   import Desugarer.*
   import Elaborator.Ctx
   import elaborator.term
-  import state.nextUid
   import tl.*
 
   // We're working on composing continuations in the UCS translation.
@@ -71,14 +70,14 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
   extension (symbol: BlockLocalSymbol)
     def getSubScrutinees(cls: ClassSymbol): List[BlockLocalSymbol] =
       subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData).classes.getOrElseUpdate(cls, {
-        (0 until cls.arity).map(i => TempSymbol(nextUid, N, s"param$i")).toList
+        (0 until cls.arity).map(i => TempSymbol(N, s"param$i")).toList
       })
     def getTupleLeadSubScrutinee(index: Int): BlockLocalSymbol =
       val data = subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData)
-      data.tupleLead.getOrElseUpdate(index, TempSymbol(nextUid, N, s"first$index"))
+      data.tupleLead.getOrElseUpdate(index, TempSymbol(N, s"first$index"))
     def getTupleLastSubScrutinee(index: Int): BlockLocalSymbol =
       val data = subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData)
-      data.tupleLast.getOrElseUpdate(index, TempSymbol(nextUid, N, s"last$index"))
+      data.tupleLast.getOrElseUpdate(index, TempSymbol(N, s"last$index"))
 
 
   def default: Split => Sequel = split => _ => split
@@ -164,7 +163,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
           pre = s"termSplit: let ${ident.name} = $termTree",
           post = (res: Split) => s"termSplit: let >>> $res"
         ):
-          val sym = VarSymbol(ident, nextUid)
+          val sym = VarSymbol(ident)
           val fallbackCtx = ctx + (ident.name -> sym)
           Split.Let(sym, term(termTree)(using ctx), elabFallback(fallback)(fallbackCtx)).withLocOf(t)
         case Modified(Keyword.`else`, elsLoc, default) => fallback => ctx => trace(
@@ -222,7 +221,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
           val first = Fld(FldFlags.empty, lhsSymbol.ref(/* FIXME ident? */), N)
           val second = Fld(FldFlags.empty, rhsTerm, N)
           val arguments = Term.Tup(first :: second :: Nil)(rawTup)
-          val joint = FlowSymbol("‹applied-result›", nextUid)
+          val joint = FlowSymbol("‹applied-result›")
           Term.App(opRef, arguments)(tree, joint)
         termSplit(rhs, finishInner)(fallback)
     case tree @ App(lhs, blk @ OpBlock(opRhsApps)) => fallback => ctx =>
@@ -232,14 +231,14 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
           val second = Fld(FldFlags.empty, rhsTerm, N)
           val rawTup = Tup(lhs :: Nil): Tup // <-- loc might be wrong
           val arguments = Term.Tup(first :: second :: Nil)(rawTup)
-          val joint = FlowSymbol("‹applied-result›", nextUid)
+          val joint = FlowSymbol("‹applied-result›")
           Term.App(op, arguments)(tree, joint)
         opRhsApps.foldRight(Function.const(fallback): Sequel): (tt, elabFallback) =>
           tt match
           case (Tree.Empty(), LetLike(`let`, ident @ Ident(_), termTree, N)) => ctx =>
             termTree match
             case S(termTree) =>
-              val sym = VarSymbol(ident, nextUid)
+              val sym = VarSymbol(ident)
               val fallbackCtx = ctx + (ident.name -> sym)
               Split.Let(sym, term(termTree)(using ctx), elabFallback(fallbackCtx))
           case (Tree.Empty(), Modified(Keyword.`else`, elsLoc, default)) => ctx =>
@@ -268,7 +267,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
       cont(symbol)(innerCtx)
     case _ =>
       val name = "scrut"
-      val symbol = TempSymbol(nextUid, N, name)
+      val symbol = TempSymbol(N, name)
       val innerCtx = baseCtx + (name -> symbol)
       Split.Let(symbol, scrutinee, cont(symbol)(innerCtx))
 
@@ -320,7 +319,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
       case LetLike(`let`, ident @ Ident(_), termTree, N) => backup => ctx =>
         termTree match
         case S(termTree) =>
-          val sym = VarSymbol(ident, nextUid)
+          val sym = VarSymbol(ident)
           val fallbackCtx = ctx + (ident.name -> sym)
           Split.Let(sym, term(termTree)(using ctx), elabFallback(backup)(fallbackCtx))
       case Modified(Keyword.`else`, elsLoc, body) => backup => ctx => trace(
@@ -381,13 +380,13 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
       case Ident("_") => _ => ctx => sequel(ctx)
       // Alias pattern
       case pat as (alias @ Ident(_)) => fallback =>
-        val aliasSymbol = VarSymbol(alias, nextUid)
+        val aliasSymbol = VarSymbol(alias)
         val inner = (ctx: Ctx) =>
           val ctxWithAlias = ctx + (alias.name -> aliasSymbol)
           Split.Let(aliasSymbol, ref, sequel(ctxWithAlias))
         expandMatch(scrutSymbol, pat, inner)(fallback)
       case id @ Ident(nme) if nme.headOption.forall(_.isLower) => fallback => ctx =>
-        val aliasSymbol = VarSymbol(id, nextUid)
+        val aliasSymbol = VarSymbol(id)
         val ctxWithAlias = ctx + (nme -> aliasSymbol)
         Split.Let(aliasSymbol, ref, sequel(ctxWithAlias) ++ fallback)
       case ctor @ (_: Ident | _: Sel) => fallback => ctx =>
@@ -418,7 +417,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
         def fld(t: Term) = Fld(FldFlags.empty, t, N)
         def tup(xs: Fld*) = Term.Tup(xs.toList)(Tup(Nil))
         def app(lhs: Term, rhs: Term, sym: FlowSymbol) = Term.App(lhs, rhs)(Tree.App(Tree.Empty(), Tree.Empty()), sym)
-        def getLast(i: Int) = TempSymbol(nextUid, N, s"last$i")
+        def getLast(i: Int) = TempSymbol(N, s"last$i")
         // `wrap`: add let bindings for tuple elements
         // `matches`: pairs of patterns and symbols to be elaborated
         val (wrapRest, restMatches) = rest match
@@ -434,7 +433,7 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)
             rest match
               case N => (wrapLast, lastMatches)
               case S(pat) =>
-                val sym = TempSymbol(nextUid, N, "rest")
+                val sym = TempSymbol(N, "rest")
                 val wrap = (split: Split) =>
                   Split.Let(sym, app(tupleSlice, tup(fld(ref), fld(int(lead.length)), fld(int(last.length))), sym), wrapLast(split))
                 (wrap, (sym, pat) :: lastMatches)

hkmc2/shared/src/main/scala/hkmc2/semantics/Elaborator.scala

@@ -84,20 +84,16 @@ object Elaborator:
     ))
   type Ctxl[A] = Ctx ?=> A
   def ctx: Ctxl[Ctx] = summon
-  class State:
-    private var curUi = 0
-    def nextUid: Int = { curUi += 1; curUi }
+  class State
 import Elaborator.*
 
 class Elaborator(val tl: TraceLogger, val wd: os.Path)
 (using val raise: Raise, val state: State)
 extends Importer:
-  import state.nextUid
   import tl.*
 
   // * Ref allocation skolem UID, preserved
-  private val allocSkolemUID = nextUid
-  private val allocSkolemSym = VarSymbol(Ident("Alloc"), allocSkolemUID)
+  private val allocSkolemSym = VarSymbol(Ident("Alloc"))
   private val allocSkolemDef = TyParam(FldFlags.empty, N, allocSkolemSym)
   allocSkolemSym.decl = S(allocSkolemDef)
 
@@ -160,7 +156,7 @@ extends Importer:
       lhs match
       case id: Ident =>
         val lt = term(lhs)
-        val sym = TempSymbol(nextUid, S(lt), "old")
+        val sym = TempSymbol(S(lt), "old")
         Term.Blk(
         LetDecl(sym) :: DefineVar(sym, lt) :: Nil, Term.Try(Term.Blk(
           Term.Assgn(lt, term(rhs)) :: Nil,
@@ -211,7 +207,7 @@ extends Importer:
     case InfixApp(TyTup(tvs), Keyword.`->`, body) =>
       val boundVars = mutable.HashMap.empty[Str, VarSymbol]
       def genSym(id: Tree.Ident) =
-        val sym = VarSymbol(id, nextUid)
+        val sym = VarSymbol(id)
         sym.decl = S(TyParam(FldFlags.empty, N, sym)) // TODO vce
         boundVars += id.name -> sym
         sym
@@ -258,7 +254,7 @@ extends Importer:
     case App(Ident("~"), Tree.Tup(rhs :: Nil)) =>
       term(rhs)
     case tree @ App(lhs, rhs) =>
-      val sym = FlowSymbol("‹app-res›", nextUid)
+      val sym = FlowSymbol("‹app-res›")
       val lt = term(lhs)
       val rt = term(rhs)
 
@@ -312,7 +308,7 @@ extends Importer:
     case Tree.Quoted(body) => Term.Quoted(term(body))
     case Tree.Unquoted(body) => Term.Unquoted(term(body))
     case Tree.Case(branches) =>
-      val scrut = VarSymbol(Ident("caseScrut"), nextUid)
+      val scrut = VarSymbol(Ident("caseScrut"))
       val desugarer = new Desugarer(tl, this)
       val des = desugarer.patternSplit(branches, scrut)(Split.End)(ctx)
       scoped("ucs:desugared"):
@@ -330,7 +326,7 @@ extends Importer:
     case TypeDef(Mod, head, N, N) =>
       term(head)
     case Tree.Region(id: Tree.Ident, body) =>
-      val sym = VarSymbol(id, nextUid)
+      val sym = VarSymbol(id)
       val nestCtx = ctx + (id.name -> sym)
       Term.Region(sym, term(body)(using nestCtx))
     case Tree.RegRef(reg, value) => Term.RegRef(term(reg), term(value))
@@ -357,13 +353,13 @@ extends Importer:
         // * TODO would be better to keep the fixity of applications part of the Tree repr.
         case (ap @ App(f: Ident, tup @ Tup(lhs :: args))) :: trees if !f.name.head.isLetter =>
           val res = go(acc, lhs :: Nil)
-          val sym = FlowSymbol("‹app-res›", nextUid)
+          val sym = FlowSymbol("‹app-res›")
           val fl = Fld(FldFlags.empty, res, N)
           val app = Term.App(term(f), Term.Tup(
             fl :: args.map(fld))(tup))(ap, sym)
           go(app, trees)
         case (ap @ App(f, tup @ Tup(args))) :: trees =>
-          val sym = FlowSymbol("‹app-res›", nextUid)
+          val sym = FlowSymbol("‹app-res›")
           go(Term.App(term(f),
               Term.Tup(Fld(FldFlags.empty, acc, N) :: args.map(fld))(tup)
             )(ap, sym), trees)
@@ -556,7 +552,7 @@ extends Importer:
               val st = td.annotatedResultType.orElse(newSignatureTrees.get(id.name))
               val s = st.map(term(_)(using newCtx))
               val b = rhs.map(term(_)(using newCtx))
-              val r = FlowSymbol(s"‹result of ${sym}›", nextUid)
+              val r = FlowSymbol(s"‹result of ${sym}›")
               val tdf = TermDefinition(owner, k, sym, pss, s, b, r, 
                 TermDefFlags.empty.copy(isModMember = isModMember))
               sym.defn = S(tdf)
@@ -612,7 +608,7 @@ extends Importer:
                   (id, S(false))
                 case Modified(Keyword.`out`, outLoc, id: Ident) =>
                   (id, S(true))
-              val vs = VarSymbol(id, nextUid)
+              val vs = VarSymbol(id)
               val res = TyParam(FldFlags.empty, vce, vs)
               vs.decl = S(res)
               res :: Nil
@@ -697,7 +693,7 @@ extends Importer:
 
   def fieldOrVarSym(k: TermDefKind, id: Ident)(using Ctx): LocalSymbol & NamedSymbol =
     if ctx.outer.isDefined then TermSymbol(k, ctx.outer, id)
-    else VarSymbol(id, nextUid)
+    else VarSymbol(id)
 
   def param(t: Tree): Ctxl[Ls[Param]] = t match
     case TypeDef(Mod, inner, N, N) =>
@@ -721,7 +717,7 @@ extends Importer:
     case TyTup(ps) =>
       val vs = ps.map:
         case id: Ident =>
-          val sym = VarSymbol(id, nextUid)
+          val sym = VarSymbol(id)
           sym.decl = S(TyParam(FldFlags.empty, N, sym))
           Param(FldFlags.empty, sym, N)
       (vs, ctx ++ vs.map(p => p.sym.name -> p.sym))
@@ -731,7 +727,7 @@ extends Importer:
     val boundVars = mutable.HashMap.empty[Str, VarSymbol]
     def go(t: Tree): Pattern = t match
       case id @ Ident(name) =>
-        val sym = boundVars.getOrElseUpdate(name, VarSymbol(id, nextUid))
+        val sym = boundVars.getOrElseUpdate(name, VarSymbol(id))
         Pattern.Var(sym)
       // case Tup(fields) =>
       //   val pats = fields.map(

hkmc2/shared/src/main/scala/hkmc2/semantics/Symbol.scala

@@ -55,30 +55,32 @@ abstract class Symbol extends Located:
 end Symbol
 
 
-class FlowSymbol(label: Str, uid: Int) extends Symbol:
+class FlowSymbol(label: Str) extends Symbol:
   def nme: Str = label
   def toLoc: Option[Loc] = N // TODO track source trees of flows
   import typing.*
   val outFlows: mutable.Buffer[FlowSymbol] = mutable.Buffer.empty
   val outFlows2: mutable.Buffer[Consumer] = mutable.Buffer.empty
   val inFlows: mutable.Buffer[ConcreteProd] = mutable.Buffer.empty
-  override def toString: Str = s"$label@$uid"
+  override def toString: Str =
+    label
+    // s"$label@$uid"
 
 
 sealed trait LocalSymbol extends Symbol
 sealed trait NamedSymbol extends Symbol:
   def name: Str
   def id: Ident
 
-abstract class BlockLocalSymbol(name: Str, uid: Int) extends FlowSymbol(name, uid) with LocalSymbol:
+abstract class BlockLocalSymbol(name: Str) extends FlowSymbol(name) with LocalSymbol:
   var decl: Opt[Declaration] = N
 
-class TempSymbol(uid: Int, val trm: Opt[Term], dbgNme: Str = "tmp") extends BlockLocalSymbol(dbgNme, uid):
+class TempSymbol(val trm: Opt[Term], dbgNme: Str = "tmp") extends BlockLocalSymbol(dbgNme):
   val nameHints: MutSet[Str] = MutSet.empty
   override def toLoc: Option[Loc] = trm.flatMap(_.toLoc)
   override def toString: Str = s"$$${super.toString}"
 
-class VarSymbol(val id: Ident, uid: Int) extends BlockLocalSymbol(id.name, uid) with NamedSymbol:
+class VarSymbol(val id: Ident) extends BlockLocalSymbol(id.name) with NamedSymbol:
   val name: Str = id.name
   // override def toString: Str = s"$name@$uid"
 

hkmc2/shared/src/main/scala/hkmc2/typing/TypeChecker.scala

@@ -87,7 +87,7 @@ class TypeChecker(using raise: Raise):
       P.Ctor(TupSymbol(S(fields.size)), fields.map(f => typeProd(f.value)))
     case Error =>
       P.Ctor(Extr(false), Nil)
-    case _ => P.Flow(FlowSymbol("TODO", 666)) // TODO
+    case _ => P.Flow(FlowSymbol("TODO")) // TODO
 
   def typeParams(ps: Ls[Param]): Ls[(C, P)] =
     ps.map: p =>