Move All Resolution to the Resolution Stage

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

@@ -194,7 +194,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   final def term(t: st, inStmtPos: Bool = false)(k: Result => Block)(using Subst): Block =
     tl.log(s"Lowering.term ${t.showDbg.truncate(100, "[...]")}${
       if inStmtPos then " (in stmt)" else ""}${
-      t.symbol.fold("")(" – symbol " + _)}")
+      t.resolvedSymbol.fold("")(" – symbol " + _)}")
 
     def warnStmt = if inStmtPos then
       raise:
@@ -306,7 +306,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         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]):
+      val isMlsFun = f.resolvedSymbol.fold(f.isInstanceOf[st.Lam]):
         case _: sem.BuiltinSymbol => true
         case sym: sem.BlockMemberSymbol =>
           sym.trmImplTree.fold(sym.clsTree.isDefined)(_.k is syntax.Fun)
@@ -320,17 +320,17 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
           subTerm_nonTail(arg): ar =>
             k(Call(fr, Arg(spread = true, ar) :: Nil)(isMlsFun, true).withLocOf(t))
       f match
-      case t if t.symbol.isDefined && (t.symbol.get is ctx.builtins.js.try_catch) =>
+      case t if t.resolvedSymbol.isDefined && (t.resolvedSymbol.get is ctx.builtins.js.try_catch) =>
         conclude(Value.Ref(State.runtimeSymbol).selN(Tree.Ident("try_catch")))
-      case t if t.symbol.isDefined && (t.symbol.get is ctx.builtins.debug.printStack) =>
+      case t if t.resolvedSymbol.isDefined && (t.resolvedSymbol.get is ctx.builtins.debug.printStack) =>
         if !config.effectHandlers.exists(_.debug) then
           raise(ErrorReport(
             msg"Debugging functions are not enabled" ->
             t.toLoc :: Nil,
             source = Diagnostic.Source.Compilation))
           return End("error")
         conclude(Value.Ref(State.runtimeSymbol).selSN("raisePrintStackEffect").withLocOf(f))
-      case t if t.symbol.isDefined && (t.symbol.get is ctx.builtins.debug.getLocals) =>
+      case t if t.resolvedSymbol.isDefined && (t.resolvedSymbol.get is ctx.builtins.debug.getLocals) =>
         if !config.effectHandlers.exists(_.debug) then
           raise(ErrorReport(
             msg"Debugging functions are not enabled" ->

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

@@ -635,8 +635,16 @@ class Resolver(tl: TraceLogger)
     case _ =>
 
     t match
+    // If a reference was not resolved to take implicit arguments or
+    // return some module type, then its result symbol is the same as
+    // the symbol it refers to.
     case t: Term.Ref if t.resSym.isEmpty =>
       t.resSym = S(t.sym)
+    // If a type application was not resolved to take implicit
+    // arguments, then its result symbol is the same as the symbol its
+    // LHS.
+    case t: Term.TyApp if t.sym.isEmpty =>
+      t.sym = t.lhs.resolvedSymbol
     case _ =>
 
   def resolveArg(p: Param)(lhs: Term)(using ictx: ICtx): Elem =
@@ -766,7 +774,7 @@ object ModuleChecker:
     t match
       case Term.Blk(_, res) => evalsToModule(res)
       case Term.IfLike(`if`, split) => split.results.exists(evalsToModule(_))
-      case t => t.symbol.exists(checkSym)
+      case t => t.resolvedSymbol.exists(checkSym)
 
 extension [T](xs: Ls[Opt[T]])
   def sequence: Opt[Ls[T]] =

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

@@ -49,7 +49,7 @@ sealed trait ResolvableImpl:
     case S(iargsLs) => iargsLs.foldLeft(t.withoutIArgs): (t, args) => 
       Term.App(t, args)(Tree.DummyApp, N, FlowSymbol("implicit app")).noIArgs // N: todo
 
-  def defn: Opt[Definition] = t.symbol match
+  def defn: Opt[Definition] = t.resolvedSymbol match
     case S(sym: MemberSymbol[?]) => sym.defn
     case S(sym: BlockLocalSymbol) => sym.decl match
       case S(td: Definition) => S(td)
@@ -84,7 +84,7 @@ enum Term extends Statement:
   case Builtin(id: Tree.Ident, nme: Str)
   case Ref(sym: Symbol)(val tree: Tree.Ident, val refNum: Int, var resSym: Opt[Symbol]) extends Term with ResolvableImpl
   case App(lhs: Term, rhs: Term)(val tree: Tree.App, var sym: Opt[FieldSymbol], val resSym: FlowSymbol) extends Term with ResolvableImpl
-  case TyApp(lhs: Term, targs: Ls[Term])(var sym: Opt[FieldSymbol]) extends Term with ResolvableImpl
+  case TyApp(lhs: Term, targs: Ls[Term])(var sym: Opt[Symbol]) extends Term with ResolvableImpl
   case Sel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with ResolvableImpl
   case SynthSel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with ResolvableImpl
   case DynSel(prefix: Term, fld: Term, arrayIdx: Bool)
@@ -115,15 +115,29 @@ enum Term extends Statement:
   case Handle(lhs: LocalSymbol, rhs: Term, args: List[Term],
     derivedClsSym: ClassSymbol, defs: Ls[HandlerTermDefinition], body: Term)
 
-  def symbol: Opt[Symbol] = this match
-    case ref: Ref if ref.resSym.nonEmpty => ref.resSym
+  /**
+   * The prelinminary symbol for the term that is resolved during
+   * elaboration. 
+   */
+  lazy val symbol: Opt[Symbol] = this match
     case Ref(sym) => S(sym)
     case sel: Sel => sel.sym
     case sel: SynthSel => sel.sym
     case sel: SelProj => sel.sym
+    case TyApp(lhs = lhs) => lhs.symbol
+    case _ => N
+
+  /**
+   * The symbol representing the evaluation result of the term. This
+   * symbol is resolved during the resolution stage.
+   */
+  def resolvedSymbol: Opt[Symbol] = this match
+    case ref: Ref => ref.resSym
+    case sel: Sel => sel.sym
+    case sel: SynthSel => sel.sym
+    case sel: SelProj => sel.sym
     case app: App => app.sym
-    case tyApp: TyApp if tyApp.sym.nonEmpty => tyApp.sym
-    case TyApp(prefix, _) => prefix.symbol
+    case tyApp: TyApp => tyApp.sym
     case _ => N
 
   def sel(id: Tree.Ident, sym: Opt[FieldSymbol]): Sel =
@@ -183,7 +197,8 @@ sealed trait Statement extends AutoLocated with ProductWithExtraInfo:
 
   def extraInfo: Str = this match
     case ref: Ref if ref.resSym.isEmpty => ""
-    case r: (Resolvable & Term | SelProj) => r.symbol.mkString
+    case r: Resolvable => r.resolvedSymbol.mkString
+    case r: SelProj => r.symbol.mkString
     case _ => ""
 
   def subStatements: Ls[Statement] = this match

hkmc2/shared/src/main/scala/hkmc2/utils/utils.scala

@@ -87,7 +87,7 @@ extension (t: Product)
         t match
           case t: Resolvable if t.iargsLs.forall(_.nonEmpty) =>
             args = args ++ Iterator:
-              "iargs = " + aux(t.iargsLs)
+              "iargsLs = " + aux(t.iargsLs)
           case _ =>
         prefix + locally:
           if inTailPos then ": \\\n" + args.mkString("\n")

hkmc2/shared/src/test/mlscript/backlog/NamedArgs.mls

@@ -39,15 +39,15 @@ id(a: 0)
 //│     lhs = SynthSel{member:id}:
 //│       prefix = Ref:
 //│         sym = member:Predef
-//│         iargs = N
+//│         iargsLs = N
 //│       nme = Ident of "id"
-//│       iargs = N
+//│       iargsLs = N
 //│     rhs = Tup of Ls of 
 //│       Fld:
 //│         flags = ()
 //│         term = Lit of StrLit of "a"
 //│         asc = S of Lit of IntLit of 0
-//│     iargs = N
+//│     iargsLs = N
 //│ = {a: 0}
 
 id of a: 0

hkmc2/shared/src/test/mlscript/codegen/FieldSymbols.mls

@@ -15,15 +15,15 @@ Foo(42).x
 //│     prefix = App:
 //│       lhs = Ref:
 //│         sym = member:Foo
-//│         iargs = N
+//│         iargsLs = N
 //│       rhs = Tup of Ls of 
 //│         Fld:
 //│           flags = ()
 //│           term = Lit of IntLit of 42
 //│           asc = N
-//│       iargs = N
+//│       iargsLs = N
 //│     nme = Ident of "x"
-//│     iargs = N
+//│     iargsLs = N
 //│ = 42
 
 
@@ -39,9 +39,9 @@ foo.x
 //│   res = Sel:
 //│     prefix = Ref:
 //│       sym = foo
-//│       iargs = N
+//│       iargsLs = N
 //│     nme = Ident of "x"
-//│     iargs = N
+//│     iargsLs = N
 //│ = 42
 
 
@@ -54,9 +54,9 @@ foo.y
 //│   res = Sel:
 //│     prefix = Ref:
 //│       sym = foo
-//│       iargs = N
+//│       iargsLs = N
 //│     nme = Ident of "y"
-//│     iargs = N
+//│     iargsLs = N
 //│ = 42
 
 
@@ -84,26 +84,26 @@ case
 //│         head = Branch:
 //│           scrutinee = Ref:
 //│             sym = caseScrut
-//│             iargs = N
+//│             iargsLs = N
 //│           pattern = ClassLike:
 //│             sym = class:Foo
 //│             trm = SynthSel{class:Foo}:
 //│               prefix = Ref:
 //│                 sym = member:Foo
-//│                 iargs = N
+//│                 iargsLs = N
 //│               nme = Ident of "class"
-//│               iargs = N
+//│               iargsLs = N
 //│             args = S of Ls of 
 //│               S of $param0
 //│             refined = false
 //│           continuation = Let:
 //│             sym = a
 //│             term = Ref:
 //│               sym = $param0
-//│               iargs = N
+//│               iargsLs = N
 //│             tail = Else of Ref:
 //│               sym = a
-//│               iargs = N
+//│               iargsLs = N
 //│         tail = End
 //│ Lowered:
 //│ Program:

hkmc2/shared/src/test/mlscript/ctx/SymbolResolution.mls

@@ -151,7 +151,7 @@ R.bar
 //│   res = Sel{module:M}:
 //│     prefix = Ref{member:R} of member:R
 //│     nme = Ident of "bar"
-//│     iargs = S of Ls of 
+//│     iargsLs = S of Ls of 
 //│       Tup of Ls of 
 //│         Fld:
 //│           flags = ()
@@ -175,7 +175,7 @@ foo
 //│   stats = Nil
 //│   res = Ref{module:M}:
 //│     sym = member:foo
-//│     iargs = S of Ls of 
+//│     iargsLs = S of Ls of 
 //│       Tup of Ls of 
 //│         Fld:
 //│           flags = ()
@@ -204,7 +204,7 @@ R.bar[Int]
 //│       nme = Ident of "bar"
 //│     targs = Ls of 
 //│       Ref{member:Int} of member:Int
-//│     iargs = S of Ls of 
+//│     iargsLs = S of Ls of 
 //│       Tup of Ls of 
 //│         Fld:
 //│           flags = ()
@@ -231,7 +231,7 @@ foo[Int]
 //│     lhs = Ref{member:foo} of member:foo
 //│     targs = Ls of 
 //│       Ref{member:Int} of member:Int
-//│     iargs = S of Ls of 
+//│     iargsLs = S of Ls of 
 //│       Tup of Ls of 
 //│         Fld:
 //│           flags = ()