Term.Resolved

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

@@ -496,7 +496,7 @@ sealed abstract class Result extends AutoLocated:
     case Lambda(params, body) => params :: Nil
     case Tuple(mut, elems) => elems.map(_.value)
     case Record(mut, elems) => elems.map(_.value)
-    case Value.Ref(l) => Nil
+    case Value.Ref(l, disamb) => Nil
     case Value.This(sym) => Nil
     case Value.Lit(lit) => lit :: Nil
 
@@ -517,7 +517,7 @@ sealed abstract class Result extends AutoLocated:
     case Tuple(mut, elems) => elems.flatMap(_.value.freeVars).toSet
     case Record(mut, args) =>
       args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVars) ++ arg.value.freeVars).toSet
-    case Value.Ref(l) => Set(l)
+    case Value.Ref(l, disamb) => Set(l)
     case Value.This(sym) => Set.empty
     case Value.Lit(lit) => Set.empty
     case DynSelect(qual, fld, arrayIdx) => qual.freeVars ++ fld.freeVars
@@ -530,11 +530,11 @@ sealed abstract class Result extends AutoLocated:
     case Tuple(mut, elems) => elems.flatMap(_.value.freeVarsLLIR).toSet
     case Record(mut, args) =>
       args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVarsLLIR) ++ arg.value.freeVarsLLIR).toSet
-    case Value.Ref(l: (BuiltinSymbol | TopLevelSymbol | ClassSymbol | TermSymbol)) => Set.empty
-    case Value.Ref(l: MemberSymbol[?]) => l.defn match
+    case Value.Ref(l: (BuiltinSymbol | TopLevelSymbol | ClassSymbol | TermSymbol), disamb) => Set.empty
+    case Value.Ref(l: MemberSymbol[?], disamb) => l.defn match
       case Some(d: ClassLikeDef) => Set.empty
       case _ => Set(l)
-    case Value.Ref(l) => Set(l)
+    case Value.Ref(l, disamb) => Set(l)
     case Value.This(sym) => Set.empty
     case Value.Lit(lit) => Set.empty
     case DynSelect(qual, fld, arrayIdx) => qual.freeVarsLLIR ++ fld.freeVarsLLIR
@@ -559,19 +559,35 @@ 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)
-  def sel(id: Tree.Ident, sym: FieldSymbol): Path = Select(this, id)(S(sym))
+  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]) extends Path with ProductWithExtraInfo:
-  def extraInfo: Str = symbol.mkString
+/**
+ * @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_SelectSymbol.map(s => s"sym=${s}") :: Nil)
+      .collect:
+        case S(info) => info
+      .mkString(",")
 
 case class DynSelect(qual: Path, fld: Path, arrayIdx: Bool) extends Path
 
-enum Value extends Path:
-  case Ref(l: Local)
+enum Value extends Path with ProductWithExtraInfo:
+  case Ref(l: Local, disamb: Opt[DefinitionSymbol[?]])
   case This(sym: InnerSymbol) // TODO rm – just use Ref
   case Lit(lit: Literal)
+
+  override def extraInfo: Str = this match
+    case Ref(l, disamb) => disamb.map(s => s"disamb=${s}").mkString
+    case _ => ""
+
+object Value:
+  object Ref:
+    def apply(l: DefinitionSymbol[?]): Ref = Ref(l, S(l))
+    def apply(l: TempSymbol | VarSymbol | BuiltinSymbol): Ref = Ref(l, N)
 
 case class Arg(spread: Opt[Bool], value: Path)
 
@@ -602,6 +618,6 @@ extension (k: Block => Block)
 def blockBuilder: Block => Block = identity
 
 extension (l: Local)
-  def asPath: Path = Value.Ref(l)
+  def asPath: Path = Value.Ref(l, N)
 
 

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

@@ -139,14 +139,14 @@ 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))
+        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
-    case Value.Ref(l) =>
+    case Value.Ref(l, disamb) =>
       val l2 = l.subst
-      k(if (l2 is l) then v else Value.Ref(l2))
+      k(if (l2 is l) then v else Value.Ref(l2, disamb))
     case Value.This(sym) =>
       val sym2 = sym.subst
       k(if (sym2 is sym) then v else Value.This(sym2))

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

@@ -65,11 +65,11 @@ 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
-    case Value.Ref(l) => l.traverse
+    case Value.Ref(l, disamb) => l.traverse
     case Value.This(sym) => sym.traverse
     case Value.Lit(lit) => ()
 

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

@@ -132,7 +132,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     def apply(res: Local, uid: StateId, rest: Block) =
       Assign(res, PureCall(Value.Ref(resumptionSymbol), List(Value.Lit(Tree.IntLit(uid)))), rest)
     def unapply(blk: Block) = blk match
-      case Assign(res, PureCall(Value.Ref(`resumptionSymbol`), List(Value.Lit(Tree.IntLit(uid)))), rest) =>
+      case Assign(res, PureCall(Value.Ref(`resumptionSymbol`, _), List(Value.Lit(Tree.IntLit(uid)))), rest) =>
         Some(res, uid, rest)
       case _ => None
 
@@ -141,7 +141,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     def apply(res: Local, uid: StateId) =
       Assign(res, PureCall(Value.Ref(returnContSymbol), List(Value.Lit(Tree.IntLit(uid)))), End(""))
     def unapply(blk: Block) = blk match
-      case Assign(res, PureCall(Value.Ref(`returnContSymbol`), List(Value.Lit(Tree.IntLit(uid)))), _) =>
+      case Assign(res, PureCall(Value.Ref(`returnContSymbol`, _), List(Value.Lit(Tree.IntLit(uid)))), _) =>
         Some(res, uid)
       case _ => None
 
@@ -157,7 +157,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     def unapply(blk: Block) = blk match
       case Assign(
           res,
-          PureCall(Value.Ref(`callSymbol`), List(Value.Lit(Tree.IntLit(uid)))),
+          PureCall(Value.Ref(`callSymbol`, _), List(Value.Lit(Tree.IntLit(uid)))),
           Assign(_, c, rest)) =>
         Some(res, uid, c, rest)
       case _ => None
@@ -167,15 +167,15 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     def apply(uid: StateId) =
       Return(PureCall(Value.Ref(transitionSymbol), List(Value.Lit(Tree.IntLit(uid)))), false)
     def unapply(blk: Block) = blk match
-      case Return(PureCall(Value.Ref(`transitionSymbol`), List(Value.Lit(Tree.IntLit(uid)))), false) =>
+      case Return(PureCall(Value.Ref(`transitionSymbol`, _), List(Value.Lit(Tree.IntLit(uid)))), false) =>
         S(uid)
       case _ => N
 
   object FnEnd:
     private val fnEndSymbol = freshTmp("fnEnd")
     def apply() = Return(PureCall(Value.Ref(fnEndSymbol), Nil), false)
     def unapply(blk: Block) = blk match
-      case Return(PureCall(Value.Ref(`fnEndSymbol`), Nil), false) => true
+      case Return(PureCall(Value.Ref(`fnEndSymbol`, _), Nil), false) => true
       case _ => false
 
   private class FreshId:
@@ -522,7 +522,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
               ResultPlaceholder(res, freshId(), c2, k(Value.Ref(res)))
         case r => super.applyResult(r)(k)
       override def applyPath(p: Path)(k: Path => Block): Block = p match
-        case Value.Ref(`getLocalsSym`) => k(handlerCtx.debugInfo.prevLocalsFn.get)
+        case Value.Ref(`getLocalsSym`, _) => k(handlerCtx.debugInfo.prevLocalsFn.get)
         case _ => super.applyPath(p)(k)
       override def applyLam(lam: Lambda): Lambda =
         // This should normally be unreachable due to prior desugaring of lambda
@@ -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)), params)(true, true))
+          S(Call(Select(owner.asPath, Tree.Ident(f.sym.nme))(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,
@@ -657,7 +659,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
         handler.sym, handler.params,
         Define(
           fDef,
-          Return(PureCall(paths.mkEffectPath, h.cls.asPath :: Value.Ref(sym) :: Nil), false)))
+          Return(PureCall(paths.mkEffectPath, h.cls.asPath :: Value.Ref(sym, N) :: Nil), false)))
 
     // Some limited handling of effects extending classes and having access to their fields.
     // Currently does not support super() raising effects.
@@ -686,7 +688,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
     val body = blockBuilder
       .define(clsDefn)
-      .assign(h.lhs, Instantiate(mut = true, Value.Ref(clsDefn.sym), Nil))
+      .assign(h.lhs, Instantiate(mut = true, Value.Ref(clsDefn.sym, S(h.cls)), Nil))
       .rest(handlerBody)
 
     val defn = FunDefn(
@@ -734,7 +736,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
       val transform = new BlockTransformerShallow(SymbolSubst()):
         override def applyResult(r: Result)(k: Result => Block): Block = 
           r match
-            case c @ Call(Value.Ref(s: BuiltinSymbol), _) => ()
+            case c @ Call(Value.Ref(s: BuiltinSymbol, _), _) => ()
             case c: Call if !c.mayRaiseEffects => ()
             case _: Call | _: Instantiate => containsCall = true
             case _ => ()
@@ -791,7 +793,8 @@ 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 /* 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/LambdaRewriter.scala

@@ -28,7 +28,7 @@ object LambdaRewriter:
             case lam: Lambda => 
               val sym = BlockMemberSymbol("lambda", Nil, nameIsMeaningful = false)
               lambdasList ::= (sym -> super.applyLam(lam))
-              k(Value.Ref(sym))
+              k(Value.Ref(sym, N))
             case _ => super.applyResult(r)(k)
         val blk = lambdaRewriter.applyBlock(b)
         (blk, lambdasList)