Move implicit argument resolution to resolution stage.

Author: FlandiaYingman

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

@@ -198,7 +198,12 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
     def warnStmt = if inStmtPos then
       raise:
         WarningReport(msg"Pure expression in statement position" -> t.toLoc :: Nil, S(t))
+    
+    // Funny Scala: the non-exhaustive match is actually the second match
     t match
+      case t: sem.Resolvable => t.instantiate
+      case t => t
+    match
     case st.UnitVal() => k(unit)
     case st.Lit(lit) =>
       warnStmt
@@ -605,13 +610,6 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       case sem.Fld(sem.FldFlags.benign(), idx, S(rhs)) => L(idx -> rhs)
       case arg @ sem.Fld(flags, value, asc) => TODO(s"Other argument forms: $arg")
       case spd: Spd => R(true -> spd.term)
-      case ca: sem.CtxArg => ca.term match
-        case S(t) => 
-          R(false -> t)
-        case N => 
-          // * All contextual arguments should have been
-          // * populated by implicit resolution before lowering.
-          lastWords(s"Found unpopulated contextual argument: ${ca}.")
     // * The straightforward way to lower arguments creates too much recursion depth
     // * and makes Lowering stack overflow when lowering functions with lots of arguments.
     /* 

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

@@ -290,10 +290,6 @@ extends Importer:
 
   def term(tree: Tree, inAppPrefix: Bool = false, inTyAppPrefix: Bool = false): Ctxl[Term] =
   trace[Term](s"Elab term ${tree.showDbg}", r => s"~> $r"):
-    def maybeApp(t: Term): Ctxl[Term] =
-      if !inAppPrefix && !inTyAppPrefix // to ensure that nested App/TyApp are only wrapped once.
-      then maybeFunctionApp(t)
-      else t
     tree.desugared match
     case unt @ Unt() => unit.withLocOf(unt)
     case Bra(k, e) =>
@@ -379,13 +375,13 @@ extends Importer:
         msg"Unsupported handle binding shape" ->
           h.toLoc :: Nil))
       Term.Error
-    case id @ Ident("this") => maybeApp:
+    case id @ Ident("this") =>
       ctx.getOuter match
       case S(sym) => sym.ref(id)
       case N =>
         raise(ErrorReport(msg"Cannot use 'this' outside of an object scope." -> tree.toLoc :: Nil))
         Term.Error
-    case id @ Ident(name) => maybeApp:
+    case id @ Ident(name) =>
       ctx.get(name) match
       case S(elem) => elem.ref(id)
       case N =>
@@ -394,7 +390,7 @@ extends Importer:
         case N =>
           raise(ErrorReport(msg"Name not found: $name" -> tree.toLoc :: Nil))
           Term.Error
-    case TyApp(lhs, targs) => maybeApp:
+    case TyApp(lhs, targs) =>
       Term.TyApp(term(lhs, inTyAppPrefix = true), targs.map {
         case Modified(Keyword.`in`, inLoc, arg) => Term.WildcardTy(S(term(arg)), N)
         case Modified(Keyword.`out`, outLoc, arg) => Term.WildcardTy(N, S(term(arg)))
@@ -507,13 +503,11 @@ extends Importer:
       val sym = FlowSymbol("‹app-res›")
       val lt = term(lhs, inAppPrefix = true)
       val rt = term(rhs)
-      maybeApp:
-        Term.App(lt, rt)(tree, sym)
+      Term.App(lt, rt)(tree, sym)
     case SynthSel(pre, nme) =>
       val preTrm = term(pre)
       val sym = resolveField(nme, preTrm.symbol, nme)
-      maybeApp:
-        Term.SynthSel(preTrm, nme)(sym)
+      Term.SynthSel(preTrm, nme)(sym)
     case Sel(pre, nme) =>
       val preTrm = term(pre)
       val sym = resolveField(nme, preTrm.symbol, nme)
@@ -535,8 +529,7 @@ extends Importer:
         val loc = tree.toLoc.getOrElse(???)
         Term.Lit(Tree.StrLit(loc.origin.fileName.toString))
       else
-        maybeApp:
-          Term.Sel(preTrm, nme)(sym)
+        Term.Sel(preTrm, nme)(sym)
     case MemberProj(ct, nme) =>
       val c = cls(ct, inAppPrefix = false)
       val f = c.symbol.flatMap(_.asCls) match
@@ -711,69 +704,6 @@ extends Importer:
     // case _ =>
     //   ???
 
-  /** 
-   * Function (as opposed to method) applications 
-   * that may require further elaboration with type information. 
-   */
-  def maybeFunctionApp(t: Term): Ctxl[Term] =
-    // * Some function definitions might not be fully elaborated yet.
-    // * We need to do some very lightweight tree parsing here.
-    case class Param(ctx: Bool)(tree: Tree)
-    case class ParamList(ps: Ls[Param], ctx: Bool)(tree: Tree)
-    def param(tree: Tree): Param = tree match
-      case Tree.Modified(Keyword.`using`, _, tree) => Param(true)(tree)
-      case _ => Param(false)(tree)
-    def paramList(tree: Tree.Tup): ParamList =
-      val ps = tree.fields.map(param)
-      ParamList(ps, ps.exists(_.ctx))(tree)
-      
-    /**
-     * Zips a `fun` application term along with its parameter lists,
-     * inserting any missing contextual argument lists.
-     * 
-     * M.foo -> M.foo(<using> ...)
-     * M.foo(a, b) -> M.foo(<using> ...)(a, b)(<using> ...)
-     * 
-     * Note: This *doesn't* handle explicit contextual arguments.
-     */
-    def zip(t: Term, paramLists: Ls[ParamList]): Term = (t, paramLists) match
-      case (t, ps :: pss) if ps.ctx =>
-        val appTree = new Tree.App(Tree.Empty(), Tree.Empty())
-        val tupTree = new Tree.Tup(Nil)
-        val args = Term.Tup(ps.ps.map(_ => CtxArgImpl()))(tupTree)
-        Term.App(zip(t, pss), args)(appTree, FlowSymbol("‹app-res›"))
-      case (t @ Term.App(lhs, rhs), ps :: pss) =>
-        Term.App(zip(lhs, pss), rhs)(t.tree, t.resSym)
-      case (t, params :: pRest) =>
-        // LHS is not a app but it still expects more param lists - a partial application.
-        // Just suppose it is legal and don't fail here. 
-        // TODO: Check in the implicit resolver.
-        t
-      case (_, Nil) => t
-    
-    /**
-     * An extractor that extracts the (tree) definition of a `fun`.
-     */
-    object FunctionTreeDef:
-      def unapply(t: Term): Opt[Tree.TermDef] = t.symbol match
-        case S(sym: BlockMemberSymbol) => sym.trmTree match
-          case S(tree @ Tree.TermDef(k = Fun)) => S(tree)
-          case _ => N
-        case _ => N
-    
-    t match
-      // f[T](foo)(bar)
-      case semantics.Apps(Term.TyApp(FunctionTreeDef(tree), _), argss) =>
-        trace[Term](s"Elab `fun` application ${t.showDbg}", r => s"~> $r"):
-          zip(t, tree.paramLists.map(paramList).reverse)
-      // f(foo)(bar)
-      case semantics.Apps(FunctionTreeDef(tree), argss) =>
-        trace[Term](s"Elab `fun` application ${t.showDbg}", r => s"~> $r"):
-          zip(t, tree.paramLists.map(paramList).reverse)
-      // The definition does not exist.
-      case _ =>
-        t
-  
   def fld(tree: Tree): Ctxl[Elem] = tree match
     case InfixApp(id: Ident, Keyword.`:`, rhs) =>
       Fld(FldFlags.empty, Term.Lit(StrLit(id.name).withLocOf(id)), S(term(rhs)))