WIP (dirty commit; will be squashed)

Author: LPTK

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

@@ -19,7 +19,9 @@ object Printer:
       // ts.trmTree
     case ts: semantics.InnerSymbol => ts.nme
     case ts: semantics.BuiltinSymbol => ts.nme
-    case _ => summon[Scope].lookup_!(l)
+    case _ => summon[Scope].lookup(l) match
+      case S(str) => str
+      case N => s"‹not in scope: ${l}›"
 
   def mkDocument(blk: Block)(using Raise, Scope): Document = blk match
     case Match(scrut, arms, dflt, rest) =>
@@ -95,6 +97,10 @@ object Printer:
     case Value.Arr(elems) =>
       val docElems = elems.map(x => mkDocument(x)).mkString(", ")
       doc"[${docElems}]"
+    case Value.Rcd(args) => // case Rcd(elems: Ls[RcdArg])
+      doc"{ ${
+        args.map(x => x.idx.fold(doc"...")(p => mkDocument(p) :: ": ") :: mkDocument(x.value)).mkString(", ")
+      } }"
 
   def mkDocument(path: Path)(using Raise, Scope): Document = path match
     case Select(qual, name) =>

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

@@ -21,7 +21,7 @@ object DeBrujinSplit:
     /** Resolve the constructor in the elaborator context. */
     def resolve(ctor: Ident | Sel, params: Ls[Tree]): Opt[F] =
       val term = scoped("ucs:mute"):
-        elaborator.cls(ctor, inAppPrefix = false)
+        elaborator.cls(elaborator.term(ctor), inAppPrefix = false)
       term.symbol.flatMap(_.asClsLike).map:
         case symbol: (ClassSymbol | ModuleSymbol) =>
           val pattern = ClassLike(ConstructorLike.Symbol(symbol))

hkmc2/shared/src/main/scala/hkmc2/semantics/ucs/DeBrujinSplit.scala

@@ -9,7 +9,7 @@ import utils.TraceLogger
 import syntax.Literal
 import Keyword.{as, and, `do`, `else`, is, let, `then`}
 import collection.mutable.{HashMap, SortedSet}
-import Elaborator.{ctx, Ctxl}
+import Elaborator.{ctx, Ctxl, UnderCtx}
 import scala.annotation.targetName
 import hkmc2.semantics.ClassDef.Parameterized
 
@@ -25,11 +25,11 @@ object Desugarer:
     val tupleLast: HashMap[Int, BlockLocalSymbol] = HashMap.empty
 end Desugarer
 
-class Desugarer(val elaborator: Elaborator)
+class Desugarer(val elaborator: Elaborator)(using UnderCtx)
     (using raise: Raise, state: Elaborator.State, c: Elaborator.Ctx) extends DesugaringBase:
   import Desugarer.*
   import Elaborator.Ctx
-  import elaborator.term, elaborator.tl.*
+  import elaborator.term, elaborator.subterm, elaborator.tl.*
 
   given Ordering[Loc] = Ordering.by: loc =>
     (loc.spanStart, loc.spanEnd)
@@ -125,7 +125,7 @@ class Desugarer(val elaborator: Elaborator)
           raise(ErrorReport(msg"only one branch is supported in shorthands" -> tree.toLoc :: Nil))
         termSplitShorthands(branch, finish)(fallback)(ctx)
     case coda is rhs => fallback => ctx =>
-      nominate(ctx, finish(term(coda)(using ctx))):
+      nominate(ctx, finish(subterm(coda)(using ctx))):
         patternSplitShorthands(rhs, _)(fallback)
     case matches => fallback =>
       // There are N > 0 conjunct matches. We use `::[T]` instead of `List[T]`.
@@ -245,6 +245,25 @@ class Desugarer(val elaborator: Elaborator)
         ):
           nominate(ctx, finish(term(headCoda)(using ctx))):
             expandMatch(_, headPattern, tailSplit)(fallback)
+    // ! WARNING: this is just slop generated by Copilot. TODO: rewrite
+    case tree @ OpApp(lhs, opIdent @ Ident(opName), rhss) => fallback => ctx => trace(
+      pre = s"termSplit: after op <<< $opName",
+      post = (res: Split) => s"termSplit: after op >>> $res"
+    ):
+      // Resolve the operator.
+      val opRef = term(opIdent)
+      // Elaborate and finish the LHS. Nominate the LHS if necessary.
+      nominate(ctx, finish(term(lhs)(using ctx))): lhsSymbol =>
+        // Compose a function that takes the RHS and finishes the application.
+        val finishInner = (rhsTerm: Term) =>
+          val first = Fld(FldFlags.empty, lhsSymbol.ref(/* FIXME ident? */), N)
+          val second = Fld(FldFlags.empty, rhsTerm, N)
+          val arguments = Term.Tup(first :: second :: Nil)(Tree.DummyTup)
+          val joint = FlowSymbol("‹applied-result›")
+          Term.App(opRef, arguments)(Tree.DummyApp, joint)
+        rhss match
+        case rhs :: Nil => termSplit(rhs, finishInner)(fallback)
+        case _ => ???
     case tree @ App(opIdent @ Ident(opName), rawTup @ Tup(lhs :: rhs :: Nil)) => fallback => ctx => trace(
       pre = s"termSplit: after op <<< $opName",
       post = (res: Split) => s"termSplit: after op >>> $res"
@@ -261,6 +280,20 @@ class Desugarer(val elaborator: Elaborator)
           val joint = FlowSymbol("‹applied-result›")
           Term.App(opRef, arguments)(tree, joint)
         termSplit(rhs, finishInner)(fallback)
+    // ! WARNING: this is just slop generated by Copilot. TODO: rewrite
+    case tree @ OpSplit(lhs, rhss) => fallback => ctx =>
+      nominate(ctx, finish(term(lhs)(using ctx))): vs =>
+        val mkInnerFinish = (op: Term) => (rhsTerm: Term) =>
+          val first = Fld(FldFlags.empty, vs.ref(/* FIXME ident? */), N)
+          val second = Fld(FldFlags.empty, rhsTerm, N)
+          val rawTup = Tup(lhs :: Nil): Tup // <-- loc might be wrong
+          val arguments = Term.Tup(first :: second :: Nil)(rawTup)
+          val joint = FlowSymbol("‹applied-result›")
+          Term.App(op, arguments)(Tree.DummyApp, joint)
+        rhss.foldRight(Function.const(fallback): Sequel): (tt, elabFallback) =>
+          tt match
+          case _ =>
+            ???
     case tree @ App(lhs, blk @ OpBlock(opRhsApps)) => fallback => ctx =>
       nominate(ctx, finish(term(lhs)(using ctx))): vs =>
         val mkInnerFinish = (op: Term) => (rhsTerm: Term) =>
@@ -447,7 +480,7 @@ class Desugarer(val elaborator: Elaborator)
   def expandMatch(scrutSymbol: BlockLocalSymbol, pattern: Tree, sequel: Sequel): Split => Sequel =
     def ref = scrutSymbol.ref(/* FIXME ident? */)
     def dealWithCtorCase(ctor: Ctor, compile: Bool)(fallback: Split): Sequel = ctx =>
-      val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
+      val clsTrm = elaborator.cls(term(ctor), inAppPrefix = false)
       clsTrm.symbol.flatMap(_.asClsLike) match
       case S(cls: ClassSymbol) =>
         if compile then warn(msg"Cannot compile the class `${cls.name}`" -> ctor.toLoc)
@@ -476,7 +509,7 @@ class Desugarer(val elaborator: Elaborator)
       pre = s"expandMatch <<< ${ctor}(${args.iterator.map(_.showDbg).mkString(", ")})",
       post = (r: Split) => s"expandMatch >>> ${r.showDbg}"
     ):
-      val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
+      val clsTrm = elaborator.cls(term(ctor), inAppPrefix = false)
       clsTrm.symbol.flatMap(_.asClsLike) match
       case S(cls: ClassSymbol) =>
         val paramSymbols = cls.defn match
@@ -597,6 +630,9 @@ class Desugarer(val elaborator: Elaborator)
         dealWithAppCtorCase(app, ctor, args, false)
       case app @ App(ctor: Ctor, Tup(args)) =>
         dealWithAppCtorCase(app, ctor, args, false)
+      case app @ OpApp(lhs, ctor: Ctor, rhss) =>
+        // TODO improve (eventually remove DummyApp)
+        dealWithAppCtorCase(Tree.DummyApp, ctor, lhs :: rhss, false)
       // A single literal pattern
       case literal: Literal => fallback => ctx => trace(
         pre = s"expandMatch: literal <<< $literal",

hkmc2/shared/src/main/scala/hkmc2/semantics/ucs/Desugarer.scala

@@ -71,7 +71,7 @@ class Translator(val elaborator: Elaborator)
       case Under() => inner(Map.empty)
       case ctor @ (_: Ident | _: Sel) =>
         lazy val resolved =
-          val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
+          val clsTrm = elaborator.cls(elaborator.term(ctor), inAppPrefix = false)
           clsTrm.symbol.flatMap(_.asClsLike) match
           case S(cls: (ClassSymbol | ModuleSymbol)) =>
             Branch(scrut(), Pattern.ClassLike(cls, clsTrm, N, false)(ctor), inner(Map.empty)) ~: Split.End
@@ -87,7 +87,7 @@ class Translator(val elaborator: Elaborator)
         case ctor: Sel => resolved
       case App(ctor @ (_: Ident | _: Sel), Tup(params)) =>
         lazy val resolved =
-          val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
+          val clsTrm = elaborator.cls(elaborator.term(ctor), inAppPrefix = false)
           clsTrm.symbol.flatMap(_.asClsLike) match
           case S(cls: (ClassSymbol | ModuleSymbol)) =>
             // TODO: handle parameters
@@ -138,7 +138,7 @@ class Translator(val elaborator: Elaborator)
           inner(captures2 ++ captures1, postfixScrut2)))
     case Under() => inner(Map.empty, scrut) // TODO: check if this is correct
     case ctor @ (_: Ident | _: Sel) =>
-      val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
+      val clsTrm = elaborator.cls(elaborator.term(ctor), inAppPrefix = false)
       clsTrm.symbol.flatMap(_.asClsLike) match
       case S(cls: (ClassSymbol | ModuleSymbol)) =>
         val kind = cls match { case _: ClassSymbol => "class" case _ => "module" }