Term.Resolved

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

@@ -558,14 +558,17 @@ case class Record(mut: Bool, elems: Ls[RcdArg]) extends Result
 
 
 sealed abstract class Path extends TrivialResult:
-  def selN(id: Tree.Ident): Path = Select(this, id)(N, N)
-  def sel(id: Tree.Ident, sym: FieldSymbol): Path = Select(this, id)(S(sym), N)
+  def selN(id: Tree.Ident): Path = Select(this, id)(N)
+  def sel(id: Tree.Ident, sym: DefinitionSymbol[?]): Path = Select(this, id)(S(sym))
   def selSN(id: Str): Path = selN(new Tree.Ident(id))
   def asArg = Arg(spread = N, this)
 
-case class Select(qual: Path, name: Tree.Ident)(val symbol: Opt[FieldSymbol], val disamb: Opt[DefinitionSymbol[?]]) extends Path with ProductWithExtraInfo:
+/**
+ * @param symbol The symbol, representing the definition that this selection refers to, if known.
+ */
+case class Select(qual: Path, name: Tree.Ident)(val symbol_SelectSymbol: Opt[DefinitionSymbol[?]]) extends Path with ProductWithExtraInfo:
   def extraInfo: Str = 
-    (symbol.map(s => s"sym=${s}") :: disamb.map(s => s"disamb=${s}") :: Nil)
+    (symbol_SelectSymbol.map(s => s"sym=${s}") :: Nil)
       .collect:
         case S(info) => info
       .mkString(",")

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

@@ -139,8 +139,8 @@ class BlockTransformer(subst: SymbolSubst):
           k(if (qual2 is qual) && (fld2 is fld) then p else DynSelect(qual2, fld2, arrayIdx))
     case p @ Select(qual, name) =>
       applyPath(qual): qual2 =>
-        val sym2 = p.symbol.mapConserve(_.subst)
-        k(if (qual2 is qual) && (sym2 is p.symbol) then p else Select(qual2, name)(sym2, p.disamb))
+        val sym2 = p.symbol_SelectSymbol.mapConserve(_.subst)
+        k(if (qual2 is qual) && (sym2 is p.symbol_SelectSymbol) then p else Select(qual2, name)(sym2))
     case v: Value => applyValue(v)(k)
 
   def applyValue(v: Value)(k: Value => Block) = v match

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

@@ -65,7 +65,7 @@ class BlockTraverser:
     case DynSelect(qual, fld, arrayIdx) =>
       applyPath(qual); applyPath(fld)
     case p @ Select(qual, name) =>
-      applyPath(qual); p.symbol.foreach(_.traverse)
+      applyPath(qual); p.symbol_SelectSymbol.foreach(_.traverse)
     case v: Value => applyValue(v)
 
   def applyValue(v: Value): Unit = v match

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

@@ -591,7 +591,9 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
         f.owner match
         case None => S(Call(f.sym.asPath, params)(true, true))
         case Some(owner) => 
-          S(Call(Select(owner.asPath, Tree.Ident(f.sym.nme))(S(f.sym), N), params)(true, true))
+          S(Call(Select(owner.asPath, Tree.Ident(f.sym.nme))(S(f.innerSym.asInstanceOf)), params)(true, true))
+          // TODO:                                               ^^^^^^^^
+          // TODO: @Harry check again on asInstanceOf
       case _ => None // TODO: more than one plist
 
     FunDefn(f.owner, f.sym, f.params, translateBlock(f.body,
@@ -719,8 +721,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
     // Create the DoUnwind function
     doUnwindMap += R(clsSym) -> Select(clsSym.asPath, Tree.Ident("doUnwind"))(
-      N /* this refers to the method defined in Runtime.FunctionContFrame */,
-      N
+      N /* this refers to the method defined in Runtime.FunctionContFrame */
     )
     val newPcSym = VarSymbol(Tree.Ident("newPc"))
     val resSym = VarSymbol(Tree.Ident("res"))
@@ -792,8 +793,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
           override def applyBlock(b: Block): Block = b match
             case ReturnCont(res, uid) => Return(Call(
                 Select(clsSym.asPath, Tree.Ident("doUnwind"))(
-                  N /* this refers to the method defined in Runtime.FunctionContFrame */,
-                  N
+                  N /* this refers to the method defined in Runtime.FunctionContFrame */
                 ),
                 res.asPath.asArg :: Value.Lit(Tree.IntLit(uid)).asArg :: Nil)(true, false),
                 false

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

@@ -103,7 +103,7 @@ object Lifter:
   object RefOfBms:
     def unapply(p: Path) = p match
       case Value.Ref(l: BlockMemberSymbol, disamb) => S((l, disamb))
-      case s @ Select(_, _) => s.symbol match
+      case s @ Select(_, _) => s.symbol_SelectSymbol match
         case Some(value: BlockMemberSymbol) => S(value, N)
         case _ => N
       case _ => N
@@ -234,7 +234,8 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
 
     def read = this match
       case Sym(l) => l.asPath
-      case PubField(isym, sym) => Select(isym.asPath, Tree.Ident(sym.nme))(S(sym), N)
+      case PubField(isym, sym) => Select(isym.asPath, Tree.Ident(sym.nme))(isym.asDefnSym_TODO)
+      // TODO: isym.asInstanceOf
 
     def asArg = read.asArg
 
@@ -798,23 +799,23 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
                 msg"Uses of private fields cannot yet be lifted." -> N :: Nil,
                 N, Diagnostic.Source.Compilation
               ))
-            k(Select(value.read, t.id)(N, N))
+            k(Select(value.read, t.id)(N))
           case _ => super.applyPath(p)(k)
 
       // Rewrites this.className.class to reference the top-level definition
       case s @ Select(RefOfBms(l, disamb), Tree.Ident("class")) if !ctx.ignored(l) && ctx.isRelevant(l) =>
         // this class will be lifted, rewrite the ref to strip it of `Select`
-        k(Select(Value.Ref(l, disamb), Tree.Ident("class"))(s.symbol, N))
+        k(Select(Value.Ref(l, disamb), Tree.Ident("class"))(s.symbol_SelectSymbol))
         // TODO:            ^
         // TODO: Ref Refactorization
 
       // For objects inside classes: When an object is nested inside a class, its defn will be
       // replaced by a symbol, to which the object instance is assigned. This rewrites references
       // from the objects BlockMemberSymbol to that new symbol.
       case s @ Select(qual, ident) => 
-        s.symbol.flatMap(ctx.getLocalPath) match
-        case Some(LocalPath.Sym(value: MemberSymbol[?])) =>
-          k(Select(qual, Tree.Ident(value.nme))(S(value), N))
+        s.symbol_SelectSymbol.flatMap(ctx.getLocalPath) match
+        case Some(LocalPath.Sym(value: DefinitionSymbol[?])) =>
+          k(Select(qual, Tree.Ident(value.nme))(S(value)))
         case _ => super.applyPath(p)(k)
 
       // This is to rewrite references to classes that are not lifted (when their BlockMemberSymbol
@@ -827,7 +828,7 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
       // from the capture; otherwise, we see if that local is passed directly as a parameter to this defn.
       case Value.Ref(l, _) => ctx.getLocalCaptureSym(l) match
         case Some(captureSym) => 
-          k(Select(ctx.getLocalClosPath(l).get.read, captureSym.id)(N, N))
+          k(Select(ctx.getLocalClosPath(l).get.read, captureSym.id)(N))
         case None => ctx.getLocalPath(l) match
           case Some(value) => k(value.read)
           case None => super.applyPath(p)(k)
@@ -1027,8 +1028,9 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
             val isMutSym = VarSymbol(Tree.Ident("isMut"))
 
             var curSym = TempSymbol(None, "tmp")
+            // TODO: This special case Select(..., "class") is redundant after this PR.
             def instInner(isMut: Bool) = if c.paramsOpt.isDefined
-              then Instantiate(mut = isMut, Select(c.sym.asPath, Tree.Ident("class"))(N, N), paramArgs)
+              then Instantiate(mut = isMut, Select(c.sym.asPath, Tree.Ident("class"))(N), paramArgs)
               else Instantiate(mut = isMut, c.sym.asPath, paramArgs)
 
             val initSym = curSym
@@ -1188,10 +1190,11 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
       case c: ClsLikeDefn => c.copy(owner = N)
       case d => d
 
+    // TODO: The special case Select(..., "class") is redundant after the PR.
     def rewriteExtends(p: Path): Path = p match
       case RefOfBms(b, _) if !ctx.ignored(b) && ctx.isRelevant(b) => b.asPath
       case Select(RefOfBms(b, _), Tree.Ident("class")) if !ctx.ignored(b) && ctx.isRelevant(b) => 
-        Select(b.asPath, Tree.Ident("class"))(N, N)
+        Select(b.asPath, Tree.Ident("class"))(N)
       case _ => return p
 
     // if this class extends something, rewrite

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

@@ -68,10 +68,10 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   val lift: Bool = config.liftDefns.isDefined
 
   private lazy val unreachableFn =
-    Select(Value.Ref(State.runtimeSymbol), Tree.Ident("unreachable"))(N, N)
+    Select(Value.Ref(State.runtimeSymbol), Tree.Ident("unreachable"))(N)
 
   def unit: Path =
-    Select(Value.Ref(State.runtimeSymbol), Tree.Ident("Unit"))(S(State.unitSymbol), N)
+    Select(Value.Ref(State.runtimeSymbol), Tree.Ident("Unit"))(S(State.unitSymbol))
 
 
   def fail(err: ErrorReport): Block =
@@ -482,16 +482,20 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       // * are preserved in the call and not moved to a temporary variable.
       case sel @ Sel(prefix, nme) =>
         subTerm(prefix): p =>
-          conclude(Select(p, nme)(sel.sym, N).withLocOf(sel))
+          conclude(Select(p, nme)(sel.sym.flatMap(_.asDefnSym_TODO)).withLocOf(sel))
       case Resolved(sel @ Sel(prefix, nme), sym) =>
         subTerm(prefix): p =>
-          conclude(Select(p, nme)(sel.sym, S(sym)).withLocOf(sel))
+          // conclude(Select(p, nme)(sel.sym, S(sym)).withLocOf(sel))
+          // TODO @Harry: Check this logic.
+          conclude(Select(p, nme)(S(sym)).withLocOf(sel))
       case sel @ SelProj(prefix, _, nme) =>
         subTerm(prefix): p =>
-          conclude(Select(p, nme)(sel.sym, N).withLocOf(sel))
+          conclude(Select(p, nme)(sel.sym.flatMap(_.asDefnSym_TODO)).withLocOf(sel))
       case Resolved(sel @ SelProj(prefix, _, nme), sym) =>
         subTerm(prefix): p =>
-          conclude(Select(p, nme)(sel.sym, S(sym)).withLocOf(sel))
+          // conclude(Select(p, nme)(sel.sym, S(sym)).withLocOf(sel))
+          // TODO @Harry: Check this logic.
+          conclude(Select(p, nme)(S(sym)).withLocOf(sel))
       case _ => subTerm(f)(conclude)
     case h @ Handle(lhs, rhs, as, cls, defs, bod) =>
       if !lowerHandlers then
@@ -630,7 +634,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                       Case.Cls(ctorSym, st) -> go(tail, topLevel = false)
                     case (param, arg) :: args =>
                       val (cse, blk) = mkArgs(args)
-                      (cse, Assign(arg, Select(sr, new Tree.Ident(param.id.name).withLocOf(arg))(S(param), N), blk))
+                      (cse, Assign(arg, Select(sr, new Tree.Ident(param.id.name).withLocOf(arg))(S(param)), blk))
                   mkMatch(mkArgs(clsParams.iterator.zip(args).toList))
                 ctor.symbol.flatMap(_.asClsOrMod) match
                   case S(cls: ClassSymbol) if ctx.builtins.virtualClasses contains cls =>
@@ -657,7 +661,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                     case ((fieldName, fieldSymbol), blk) =>
                       mkMatch(
                         Case.Field(fieldName, safe = true), // we know we have an object, no need to check again
-                        Assign(fieldSymbol, Select(sr, fieldName)(N, N), blk)
+                        Assign(fieldSymbol, Select(sr, fieldName)(N), blk)
                       )
                 )
         case Split.Else(els) =>
@@ -669,7 +673,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                 else End()
               )
         case Split.End =>
-          Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N, N),
+          Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N),
             Value.Lit(syntax.Tree.StrLit("match error")).asArg :: Nil)) // TODO add failed-match scrutinee info
 
       val normalize = ucs.Normalization()
@@ -697,11 +701,13 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
     case sel @ SynthSel(prefix, nme) =>
       // * Not using `setupSelection` as these selections are not meant to be sanity-checked
       subTerm(prefix): p =>
-        k(Select(p, nme)(sel.sym, N))
+        k(Select(p, nme)(sel.sym.flatMap(_.asDefnSym_TODO)))
     case Resolved(sel @ SynthSel(prefix, nme), sym) =>
       // * Not using `setupSelection` as these selections are not meant to be sanity-checked
       subTerm(prefix): p =>
-        k(Select(p, nme)(sel.sym, S(sym)))
+        // k(Select(p, nme)(sel.sym, S(sym)))
+        // TODO @Harry: Check this logic.
+        k(Select(p, nme)(S(sym)))
 
     case DynSel(prefix, fld, ai) =>
       subTerm(prefix): p =>
@@ -755,17 +761,17 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
     case sp @ SelProj(prefix, _, proj) =>
       setupSelection(prefix, proj, sp.sym, N)(k)
     case Region(reg, body) =>
-      Assign(reg, Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Region"))(N, N), Nil),
+      Assign(reg, Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Region"))(N), Nil),
         term_nonTail(body)(k))
     case RegRef(reg, value) =>
       plainArgs(reg :: value :: Nil): args =>
-        k(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Ref"))(N, N), args))
+        k(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Ref"))(N), args))
     case Drop(ref) =>
       subTerm(ref): _ =>
         k(unit)
     case Deref(ref) =>
       subTerm(ref): r =>
-        k(Select(r, Tree.Ident("value"))(N, N))
+        k(Select(r, Tree.Ident("value"))(N))
     case SetRef(lhs, rhs) =>
       subTerm(lhs): ref =>
         subTerm_nonTail(rhs): value =>
@@ -1079,7 +1085,8 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   def setupSelection(prefix: Term, nme: Tree.Ident, sym: Opt[FieldSymbol], disamb: Opt[DefinitionSymbol[?]])(k: Result => Block)(using Subst): Block =
     subTerm(prefix): p =>
       val selRes = TempSymbol(N, "selRes") // TODO @LP: why is it here?
-      k(Select(p, nme)(sym, disamb))
+      // k(Select(p, nme)(sym, disamb))
+      k(Select(p, nme)(disamb.orElse(sym.flatMap(_.asDefnSym_TODO))))
 
   final def setupFunctionOrByNameDef(paramLists: List[ParamList], bodyTerm: Term, name: Option[Str])
       (using Subst): (List[ParamList], Block) =
@@ -1111,15 +1118,15 @@ trait LoweringSelSanityChecks(using Config, TL, Raise, State)
       // * We are careful to access `x.f` before `x.f$__checkNotMethod` in case `x` is, eg, `undefined` and
       // * the access should throw an error like `TypeError: Cannot read property 'f' of undefined`.
       val b0 = blockBuilder
-        .assign(selRes, Select(p, nme)(sym, disamb))
+        .assign(selRes, Select(p, nme)(disamb.orElse(sym.flatMap(_.asDefnSym_TODO))))
       (if sym.isDefined then
         // * If the symbol is known, the elaborator will have already checked the access [invariant:1]
         b0
       else b0
-        .assign(TempSymbol(N, "discarded"), Select(p, Tree.Ident(nme.name+"$__checkNotMethod"))(N, N)))
+        .assign(TempSymbol(N, "discarded"), Select(p, Tree.Ident(nme.name+"$__checkNotMethod"))(N)))
         .ifthen(selRes.asPath,
           Case.Lit(syntax.Tree.UnitLit(false)),
-          Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N, N),
+          Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N),
             Value.Lit(syntax.Tree.StrLit(s"Access to required field '${nme.name}' yielded 'undefined'")).asArg :: Nil))
         )
         .rest(k(selRes.asPath))
@@ -1131,7 +1138,7 @@ trait LoweringTraceLog(instrument: Bool)(using TL, Raise, State)
 
   private def selFromGlobalThis(path: Str*): Path =
       path.foldLeft[Path](Value.Ref(State.globalThisSymbol)):
-        (qual, name) => Select(qual, Tree.Ident(name))(N, N)
+        (qual, name) => Select(qual, Tree.Ident(name))(N)
 
   private def assignStmts(stmts: (Local, Result)*)(rest: Block) =
     stmts.foldRight(rest):

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

@@ -13,7 +13,7 @@ class StackSafeTransform(depthLimit: Int, paths: HandlerPaths, doUnwindMap: Map[
   private val STACK_DEPTH_IDENT: Tree.Ident = Tree.Ident("stackDepth")
 
   val doUnwindFns = doUnwindMap.values.collect:
-      case s: Select if s.symbol.isDefined => s.symbol.get
+      case s: Select if s.symbol_SelectSymbol.isDefined => s.symbol_SelectSymbol.get
       case Value.Ref(sym, _) => sym
     .toSet
 

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

@@ -154,10 +154,10 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       val (params, bodyDoc) = setupFunction(none, ps, bod)
       doc"($params) => ${ braced(bodyDoc) }"
     case s @ Select(qual, id) => 
-      val dotClass = s.symbol match
-        case S(bms: BlockMemberSymbol) if {
-          bms.hasLiftedClass && 
-          s.disamb.flatMap(d => d.asMod orElse d.asCls).exists(_ isnt ctx.builtins.Array)
+      val dotClass = s.symbol_SelectSymbol match
+        case S(ds) if {
+          (ds.hasLiftedClass) && 
+          (ds.asMod orElse ds.asCls).exists(_ isnt ctx.builtins.Array)
         } => doc".class"
         case _ => doc""
       val name = id.name