Move All Resolution to the Resolution Stage

hkmc2/shared/src/main/scala/hkmc2/MLsCompiler.scala

@@ -7,6 +7,7 @@ import utils.*
 
 import hkmc2.semantics.MemberSymbol
 import hkmc2.semantics.Elaborator
+import hkmc2.semantics.Resolver
 import semantics.Elaborator.Ctx
 import hkmc2.syntax.Keyword.`override`
 import semantics.Elaborator.State
@@ -51,6 +52,7 @@ class MLsCompiler(preludeFile: os.Path, mkOutput: ((Str => Unit) => Unit) => Uni
   // TODO adapt logic
   val etl = new TraceLogger{override def doTrace: Bool = false}
   val ltl = new TraceLogger{override def doTrace: Bool = false}
+  val rtl = new TraceLogger{override def doTrace: Bool = false}
 
 
   var dbgParsing = false
@@ -80,6 +82,8 @@ class MLsCompiler(preludeFile: os.Path, mkOutput: ((Str => Unit) => Unit) => Uni
       val elab = Elaborator(etl, wd, newCtx)
       val parsed = mainParse.resultBlk
       val (blk0, _) = elab.importFrom(parsed)
+      val resolver = Resolver(rtl)
+      resolver.traverseBlock(blk0)(using Resolver.ICtx.empty)
       val blk = new semantics.Term.Blk(
         semantics.Import(State.runtimeSymbol, runtimeFile.toString) :: blk0.stats,
         blk0.res

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

@@ -165,7 +165,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       Type.mkComposedType(typeMonoType(lhs), typeMonoType(rhs), pol)
     case _ =>
       ty.symbol.flatMap(_.asTpe) match
-      case S(cls: (ClassSymbol | TypeAliasSymbol)) => typeAndSubstType(Term.TyApp(ty, Nil), pol)
+      case S(cls: (ClassSymbol | TypeAliasSymbol)) => typeAndSubstType(Term.TyApp(ty, Nil)(N), pol)
       case S(_) => error(msg"${ty.symbol.get.getClass.toString()} is not a valid type" -> ty.toLoc :: Nil)
       case N => error(msg"Invalid type" -> ty.toLoc :: Nil) // TODO
 
@@ -220,7 +220,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       val nestCtx = ctx.nextLevel
       given BbCtx = nestCtx
       val bds = params.map:
-        case Param(_, sym, _) =>
+        case Param(sym = sym) =>
           val tv = freshVar(sym)
           val sk = freshSkolem(sym)
           nestCtx &= (sym, tv, sk)
@@ -239,7 +239,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       constrain(lhsTy, FunType(rhsTy.reverse, resTy, Bot)) // TODO: right
       (resTy, lhsCtx | rhsCtx, lhsEff | rhsEff)
     case sel @ Term.SynthSel(Term.Ref(_: TopLevelSymbol), _) if sel.symbol.isDefined =>
-      val (opTy, eff) = typeCheck(Ref(sel.symbol.get)(sel.nme, 666)) // FIXME 666
+      val (opTy, eff) = typeCheck(Ref(sel.symbol.get)(sel.nme, 666, N)) // FIXME 666
       (tryMkMono(opTy, sel), Bot, eff)
     case unq @ Term.Unquoted(body) =>
       val (ty, eff) = typeCheck(body)
@@ -343,7 +343,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       else
         val nestCtx = ctx.nest
         val argsTy = params.zip(args).map:
-          case (Param(_, sym, _), ty) =>
+          case (Param(sym = sym), ty) =>
             nestCtx += sym -> ty
             ty
         given BbCtx = nestCtx
@@ -421,7 +421,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       case Term.Annotated(Annot.Untyped, _) => (Bot, Bot)
       case sel @ Term.SynthSel(Ref(_: TopLevelSymbol), nme)
         if sel.symbol.isDefined =>
-        typeCheck(Ref(sel.symbol.get)(sel.nme, 666)) // FIXME 666
+        typeCheck(Ref(sel.symbol.get)(sel.nme, 666, N)) // FIXME 666
       case Ref(sym) =>
         ctx.get(sym) match
           case Some(ty) => (ty, Bot)
@@ -442,16 +442,16 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
             effBuff += eff
             ctx += sym -> rhsTy
             goStats(stats)
-          case TermDefinition(_, Fun, sym, ps :: Nil, _, sig, S(body), _, _, _) :: stats =>
-            typeFunDef(sym, Term.Lam(ps, body), sig, ctx)
+          case (td @ TermDefinition(k = Fun, params = ps :: Nil, sign = sig, body = S(body))) :: stats =>
+            typeFunDef(td.sym, Term.Lam(ps, body), sig, ctx)
             goStats(stats)
-          case TermDefinition(_, Fun, sym, Nil, _, sig, S(body), _, _, _) :: stats =>
-            typeFunDef(sym, body, sig, ctx)  // * may be a case expressions
+          case (td @ TermDefinition(k = Fun, params = Nil, sign = sig, body = S(body))) :: stats =>
+            typeFunDef(td.sym, body, sig, ctx)  // * may be a case expressions
             goStats(stats)
-          case TermDefinition(_, Fun, sym1, _, _, S(sig), None, _, _, _) :: (td @ TermDefinition(_, Fun, sym2, _, _, _, S(body), _, _, _)) :: stats
-            if sym1 === sym2 => goStats(td :: stats) // * avoid type check signatures twice
-          case TermDefinition(_, Fun, sym, _, _, S(sig), None, _, _, _) :: stats =>
-            ctx += sym -> typeType(sig)
+          case (td1 @ TermDefinition(k = Fun, sign = S(sig), body = None)) :: (td2 @ TermDefinition(k = Fun, body = S(body))) :: stats
+            if td1.sym === td2.sym => goStats(td2 :: stats) // * avoid type check signatures twice
+          case (td @ TermDefinition(k = Fun, sign = S(sig), body = None)) :: stats =>
+            ctx += td.sym -> typeType(sig)
             goStats(stats)
           case (clsDef: ClassDef) :: stats =>
             goStats(stats)
@@ -475,7 +475,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
         val nestCtx = ctx.nest
         given BbCtx = nestCtx
         val tvs = params.map:
-          case Param(_, sym, sign) =>
+          case Param(_, sym, sign, _) =>
             val ty = sign.map(s => typeType(s)(using nestCtx)).getOrElse(freshVar(sym))
             nestCtx += sym -> ty
             ty
@@ -495,7 +495,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
             constrain(tryMkMono(ty, term), ClassLikeType(clsSym, targs))
             require(clsDfn.paramsOpt.forall(_.restParam.isEmpty))
             (clsDfn.paramsOpt.fold(Nil)(_.params).map {
-              case Param(_, sym, sign) =>
+              case Param(_, sym, sign, _) =>
                 if sym.nme === field.name then sign else N
             }.filter(_.isDefined)) match
               case S(res) :: Nil => (typeAndSubstType(res, pol = true)(using map.toMap), eff)
@@ -527,7 +527,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
             val effBuff = ListBuffer.empty[Type]
             require(clsDfn.paramsOpt.forall(_.restParam.isEmpty))
             args.iterator.zip(clsDfn.params.params).foreach {
-              case (arg, Param(_, _, S(sign))) =>
+              case (arg, Param(sign = S(sign))) =>
                 val (ty, eff) = ascribe(arg, typeAndSubstType(sign, pol = true)(using map.toMap))
                 effBuff += eff
               case _ => ???

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

@@ -189,7 +189,7 @@ class BlockTransformer(subst: SymbolSubst):
   def applyParamList(pl: ParamList): ParamList =
     def applyParam(p: Param): Param =
       val sym2 = p.sym.subst
-      if sym2 is p.sym then p else Param(p.flags, sym2, p.sign)
+      if sym2 is p.sym then p else p.copy(sym = sym2)
     val params2 = pl.params.mapConserve(applyParam)
     val rest2 = pl.restParam.mapConserve(applyParam)
     if (params2 is pl.params) && (rest2 is pl.restParam)

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

@@ -459,7 +459,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
 
     val handlerMtds = h.handlers.map: handler =>
       val lam = Value.Lam(
-        PlainParamList(Param(FldFlags.empty, handler.resumeSym, N) :: Nil),
+        PlainParamList(Param(FldFlags.empty, handler.resumeSym, N, Modulefulness.none) :: Nil),
         translateBlock(handler.body,
           handler.params.flatMap(_.paramSyms).toSet,
           handlerMtdCtx(s"Cont$$handler$$${symToStr(h.lhs)}$$${symToStr(handler.sym)}$$", handler.sym.nme)))
@@ -584,7 +584,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
     val resumeFnDef = FunDefn(
       S(clsSym), // owner
       resumeSym,
-      List(PlainParamList(List(Param(FldFlags.empty, resumedVal, N)))),
+      List(PlainParamList(List(Param(FldFlags.empty, resumedVal, N, Modulefulness.none)))),
       resumeBody
     )
 
@@ -624,7 +624,7 @@ class HandlerLowering(paths: HandlerPaths, opt: EffectHandlers)(using TL, Raise,
       BlockMemberSymbol(clsSym.nme, Nil),
       syntax.Cls,
       S(PlainParamList({
-        val p = Param(FldFlags.empty.copy(value = true), pcVar, N)
+        val p = Param(FldFlags.empty.copy(value = true), pcVar, N, Modulefulness.none)
         pcVar.decl = S(p)
         p
       } :: Nil)),

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

@@ -244,7 +244,7 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
       val varSym = VarSymbol(Tree.Ident(nme))
       val fldSym = BlockMemberSymbol(nme, Nil)
 
-      val p = Param(FldFlags.empty.copy(value = true), varSym, None)
+      val p = Param(FldFlags.empty.copy(value = true), varSym, N, Modulefulness.none)
       varSym.decl = S(p) // * Currently this is only accessed to create the class' toString method
 
       val vd = ValDefn(
@@ -750,25 +750,25 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
         (sym, createSym(sym.nme + "$member"))
 
       val extraParamsCaptures = capturesSymbols.map: // parameter list
-        case (d, (sym, _)) => Param(FldFlags.empty, sym, None)
+        case (d, (sym, _)) => Param(FldFlags.empty, sym, N, Modulefulness.none)
       val newCapturePaths = capturesSymbols.map: // mapping from sym to param symbol
           case (d, (_, sym)) => d -> sym.asPath
         .toMap
 
       val extraParamsLocals = localsSymbols.map: // parameter list
-        case (d, (sym, _)) => Param(FldFlags.empty, sym, None)
+        case (d, (sym, _)) => Param(FldFlags.empty, sym, N, Modulefulness.none)
       val newLocalsPaths = localsSymbols.map: // mapping from sym to param symbol
           case (d, (_, sym)) => d -> sym
         .toMap
 
       val extraParamsIsyms = isymSymbols.map: // parameter list
-        case (d, (sym, _)) => Param(FldFlags.empty, sym, None)
+        case (d, (sym, _)) => Param(FldFlags.empty, sym, N, Modulefulness.none)
       val newIsymPaths = isymSymbols.map: // mapping from sym to param symbol
           case (d, (_, sym)) => d -> sym
         .toMap
 
       val extraParamsBms = bmsSymbols.map: // parameter list
-        case (d, (sym, _)) => Param(FldFlags.empty, sym, None)
+        case (d, (sym, _)) => Param(FldFlags.empty, sym, N, Modulefulness.none)
       val newBmsPaths = bmsSymbols.map: // mapping from sym to param symbol
           case (d, (_, sym)) => d -> sym.asPath
         .toMap
@@ -838,7 +838,7 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
             acc = blk => acc(Assign(curSym, call, blk))
           val bod = acc(Return(Call(curSym.asPath, extraSyms.map(_.asPath.asArg))(true, false), false))
 
-          inline def toPlist(ls: List[VarSymbol]) = PlainParamList(ls.map(s => Param(FldFlags.empty, s, N)))
+          inline def toPlist(ls: List[VarSymbol]) = PlainParamList(ls.map(s => Param(FldFlags.empty, s, N, Modulefulness.none)))
 
           val paramPlist = paramSyms.map(toPlist)
           val auxPlist = auxSyms.map(toPlist)

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
@@ -224,37 +229,39 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         if sym.binary then
           val t1 = new Tree.Ident("arg1")
           val t2 = new Tree.Ident("arg2")
-          val p1 = Param(FldFlags.empty, VarSymbol(t1), N)
-          val p2 = Param(FldFlags.empty, VarSymbol(t2), N)
+          val p1 = Param(FldFlags.empty, VarSymbol(t1), N, Modulefulness.none)
+          val p2 = Param(FldFlags.empty, VarSymbol(t2), N, Modulefulness.none)
           val ps = PlainParamList(p1 :: p2 :: Nil)
-          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666), st.Ref(p2.sym)(t2, 666)))
+          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666, N).noIArgs, st.Ref(p2.sym)(t2, 666, N).noIArgs))
             (Tree.Tup(Nil // FIXME should not be required (using dummy value)
               )))(
               Tree.App(Tree.Empty(), Tree.Empty()), // FIXME should not be required (using dummy value)
+              N,
               FlowSymbol(sym.nme)
-            )
+            ).noIArgs
           val (paramLists, bodyBlock) = setupFunctionDef(ps :: Nil, bod, S(sym.nme))
           tl.log(s"Ref builtin $sym")
           assert(paramLists.length === 1)
           return k(Value.Lam(paramLists.head, bodyBlock))
         if sym.unary then
           val t1 = new Tree.Ident("arg")
-          val p1 = Param(FldFlags.empty, VarSymbol(t1), N)
+          val p1 = Param(FldFlags.empty, VarSymbol(t1), N, Modulefulness.none)
           val ps = PlainParamList(p1 :: Nil)
-          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666)))
+          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666, N).noIArgs))
             (Tree.Tup(Nil // FIXME should not be required (using dummy value)
               )))(
               Tree.App(Tree.Empty(), Tree.Empty()), // FIXME should not be required (using dummy value)
+              N,
               FlowSymbol(sym.nme)
-            )
+            ).noIArgs
           val (paramLists, bodyBlock) = setupFunctionDef(ps :: Nil, bod, S(sym.nme))
           tl.log(s"Ref builtin $sym")
           assert(paramLists.length === 1)
           return k(Value.Lam(paramLists.head, bodyBlock))
       case bs: BlockMemberSymbol =>
         bs.defn match
         case S(d) if d.isDeclare.isDefined =>
-          return term(Sel(State.globalThisSymbol.ref(), ref.tree)(S(bs)))(k)
+          return term(Sel(State.globalThisSymbol.ref().noIArgs, ref.tree)(S(bs)).noIArgs)(k)
         case S(td: TermDefinition) if td.k is syntax.Fun =>
           // * Local functions with no parameter lists are getters
           // * and are lowered to functions with an empty parameter list
@@ -532,7 +539,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
             Return(Call(Value.Ref(State.builtinOpsMap("super")), args)(true, true), implct = true)
         val clsDef = ClsLikeDefn(N, isym, sym, syntax.Cls, N, Nil, S(clsp),
           mtds, privateFlds, publicFlds, pctor, ctor)
-        Define(clsDef, term_nonTail(New(sym.ref(), Nil, N))(k))
+        Define(clsDef, term_nonTail(New(sym.ref().noIArgs, Nil, N))(k))
 
     case Try(sub, finallyDo) =>
       val l = new TempSymbol(S(sub))
@@ -605,13 +612,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.
     /*