Add basic record syntax, which does not require curly braces

Author: LPTK

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

@@ -247,7 +247,8 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       val cr = freshVar(new TempSymbol(S(unq), "ctx"))
       constrain(tryMkMono(ty, body), BbCtx.codeTy(tv, cr))
       (tv, cr, eff)
-    case blk @ Term.Blk(LetDecl(sym, _) :: DefineVar(sym2, rhs) :: Nil, body) if sym2 is sym => // TODO: more than one!!
+    case blk @ Term.Blk(LetDecl(sym, _) :: DefineVar(sym2, rhs) :: Nil, body)
+    if sym2 is sym => // TODO: more than one!!
       val (rhsTy, rhsCtx, rhsEff) = typeCode(rhs)(using ctx)
       val nestCtx = ctx.nextLevel
       given BbCtx = nestCtx

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

@@ -22,6 +22,8 @@ case class Program(
 
 sealed abstract class Block extends Product with AutoLocated:
 
+  def ~(that: Block): Block = Begin(this, that)
+  
   protected def children: Ls[Located] = ??? // Maybe extending AutoLocated is unnecessary
 
   lazy val definedVars: Set[Local] = this match
@@ -381,12 +383,14 @@ enum Case:
     case Lit(_) => Set.empty
     case Cls(_, path) => path.freeVars
     case Tup(_, _) => Set.empty
-
+  
   lazy val freeVarsLLIR: Set[Local] = this match
     case Lit(_) => Set.empty
     case Cls(_, path) => path.freeVarsLLIR
     case Tup(_, _) => Set.empty
 
+sealed trait TrivialResult extends Result
+
 sealed abstract class Result:
 
   // TODO rm Lam from values and thus the need for this method
@@ -431,7 +435,7 @@ case class Call(fun: Path, args: Ls[Arg])(val isMlsFun: Bool, val mayRaiseEffect
 
 case class Instantiate(cls: Path, args: Ls[Path]) extends Result
 
-sealed abstract class Path 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 selSN(id: Str): Path = selN(new Tree.Ident(id))
@@ -448,9 +452,15 @@ enum Value extends Path:
   case Lit(lit: Literal)
   case Lam(params: ParamList, body: Block)
   case Arr(elems: Ls[Arg])
+  case Rcd(elems: Ls[RcdArg])
 
 case class Arg(spread: Bool, value: Path)
 
+// * `IndxdArg(S(idx), value)` represents a key-value pair in a record `(idx): value`
+// * `IndxdArg(N, value)` represents a spread element in a record `...value`
+case class RcdArg(idx: Opt[Path], value: Path):
+  def spread: Bool = idx.isEmpty
+
 extension (k: Block => Block)
 
   def chain(other: Block => Block): Block => Block = b => k(other(b))

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

@@ -132,6 +132,12 @@ class BlockTransformer(subst: SymbolSubst):
     case Value.Arr(elems) =>
       val elems2 = elems.mapConserve(applyArg)
       if (elems2 is elems) then v else Value.Arr(elems2)
+    case Value.Rcd(fields) =>
+      val fields2 = fields.mapConserve:
+        case arg @ RcdArg(idx, v) =>
+          val v2 = applyPath(v)
+          if v2 is v then arg else RcdArg(idx, v2)
+      if fields2 is fields then v else Value.Rcd(fields2)
 
   def applyLocal(sym: Local): Local = sym.subst
 

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

@@ -63,20 +63,113 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   def unit: Path =
     Select(Value.Ref(State.runtimeSymbol), Tree.Ident("Unit"))(S(summon[Ctx].builtins.Unit))
 
+  
+  type Rcd = List[RcdArg]
+  
   def returnedTerm(t: st)(using Subst): Block = term(t)(Ret)
 
   // * Used to work around Scala's @tailrec annotation for those few calls that are not in tail position.
   final def term_nonTail(t: st, inStmtPos: Bool = false)(k: Result => Block)(using Subst): Block =
     term(t: st, inStmtPos: Bool)(k)
 
+  def block(stats: Ls[Statement], res: Rcd \/ Term)(k: Result => Block)(using Subst): Block =
+    stats match
+    case (t: sem.Term) :: stats =>
+      subTerm(t, inStmtPos = true): r =>
+        block(stats, res)(r => k(r))
+    case Nil =>
+      res match
+      case R(res) => term(res)(k)
+      case L(flds) =>
+        k(Value.Rcd(flds.reverse))
+    case RcdField(lhs, rhs) :: stats =>
+      res match
+      case R(_) => wat("RcdField in non-Rcd context", res)
+      case L(flds) =>
+        subTerm(lhs): l =>
+          subTerm_nonTail(rhs): r =>
+            block(stats, L(RcdArg(S(l), r) :: flds))(k)
+    case (decl @ LetDecl(sym, annotations)) :: (stats @ ((_: DefineVar) :: _)) =>
+      reportAnnotations(decl, annotations)
+      block(stats, res)(k)
+    case (decl @ LetDecl(sym, annotations)) :: stats =>
+      reportAnnotations(decl, annotations)
+      block(DefineVar(sym, Term.Lit(Tree.UnitLit(false))) :: stats, res)(k)
+    case DefineVar(sym, rhs) :: stats =>
+      subTerm(rhs): r =>
+        Assign(sym, r, block(stats, res)(k))
+    case (imp @ Import(sym, path)) :: stats =>
+      raise(ErrorReport(
+        msg"Imports must be at the top level" ->
+        imp.toLoc :: Nil,
+        source = Diagnostic.Source.Compilation))
+      block(stats, res)(k)
+    case (d: Declaration) :: stats =>
+      d match
+      case td: TermDefinition =>
+        reportAnnotations(td, td.extraAnnotations)
+        td.body match
+        case N => // abstract declarations have no lowering
+          block(stats, res)(k)
+        case S(bod) =>
+          td.k match
+          case knd: syntax.Val =>
+            assert(td.params.isEmpty)
+            subTerm_nonTail(bod)(r =>
+              // Assign(td.sym, r,
+              //   term(st.Blk(stats, res))(k)))
+              Define(ValDefn(td.owner, knd, td.sym, r),
+                block(stats, res)(k)))
+          case syntax.Fun =>
+            val (paramLists, bodyBlock) = setupFunctionOrByNameDef(td.params, bod, S(td.sym.nme))
+            Define(FunDefn(td.owner, td.sym, paramLists, bodyBlock),
+              block(stats, res)(k))
+          case syntax.Ins =>
+            // Implicit instances are not parameterized for now.
+            assert(td.params.isEmpty)
+            subTerm(bod)(r =>
+              Define(ValDefn(td.owner, syntax.ImmutVal, td.sym, r),
+                block(stats, res)(k)))
+      case cls: ClassLikeDef if cls.sym.defn.exists(_.isDeclare.isDefined) =>
+        // * Declarations have no lowering
+        block(stats, res)(k)
+      case cls: ClassLikeDef =>
+        reportAnnotations(cls, cls.extraAnnotations)
+        val (mtds, publicFlds, privateFlds, ctor) = gatherMembers(cls.body)
+        cls.ext match
+        case N =>
+          Define(ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, Nil, N,
+                mtds,
+                privateFlds,
+                publicFlds,
+                End(),
+                ctor
+              ),
+            block(stats, res)(k))
+        case S(ext) =>
+          assert(k isnt syntax.Mod) // modules can't extend things and can't have super calls
+          subTerm(ext.cls): clsp =>
+            val pctor = // TODO dedup with New case
+              args(ext.args): args =>
+                Return(Call(Value.Ref(State.builtinOpsMap("super")), args)(true, true), implct = true)
+            Define(
+              ClsLikeDefn(
+                cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, Nil, S(clsp),
+                mtds, privateFlds, publicFlds, pctor, ctor
+              ),
+              block(stats, res)(k)
+            )
+      case td: TypeDef => // * Type definitions are erased
+        block(stats, res)(k)
+  
   @tailrec
   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 " + _)}")
     def warnStmt = if inStmtPos then
-      raise(WarningReport:
-        msg"Pure expression in statement position" -> t.toLoc :: Nil)
+      raise:
+        WarningReport(msg"Pure expression in statement position" -> t.toLoc :: Nil, S(t))
     t match
     case st.UnitVal() => k(unit)
     case st.Lit(lit) =>
@@ -234,8 +327,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         subTerm(prefix): p =>
           conclude(Select(p, nme)(sel.sym))
       case _ => subTerm(f)(conclude)
-      
-    case st.Blk((h @ Handle(lhs, rhs, as, cls, defs)) :: stmts, res) =>
+    case h @ Handle(lhs, rhs, as, cls, defs, bod) =>
       if !lowerHandlers then
         raise(ErrorReport(
           msg"Effect handlers are not enabled" ->
@@ -255,83 +347,9 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       subTerm(rhs): par =>
         subTerms(as): asr =>
           HandleBlock(lhs, resSym, par, asr, cls, handlers,
-            term_nonTail(st.Blk(stmts, res))(HandleBlockReturn(_)),
+            term_nonTail(bod)(HandleBlockReturn(_)),
             k(Value.Ref(resSym)))
-      
-    case st.TyApp(lhs, _) => term(lhs)(k)
-    case st.Blk(Nil, res) => term(res)(k)
-    case st.Blk((t: sem.Term) :: stats, res) =>
-      subTerm(t, inStmtPos = true)(r => term_nonTail(st.Blk(stats, res))(k))
-    case st.Blk((d: Declaration) :: stats, res) =>
-      d match
-      case td: TermDefinition =>
-        reportAnnotations(td, td.extraAnnotations)
-        td.body match
-        case N => // abstract declarations have no lowering
-          term(st.Blk(stats, res))(k)
-        case S(bod) =>
-          td.k match
-          case knd: syntax.Val =>
-            assert(td.params.isEmpty)
-            subTerm_nonTail(bod)(r =>
-              // Assign(td.sym, r,
-              //   term(st.Blk(stats, res))(k)))
-              Define(ValDefn(td.owner, knd, td.sym, r),
-                term_nonTail(st.Blk(stats, res))(k)))
-          case syntax.Fun =>
-            val (paramLists, bodyBlock) = setupFunctionOrByNameDef(td.params, bod, S(td.sym.nme))
-            Define(FunDefn(td.owner, td.sym, paramLists, bodyBlock),
-              term_nonTail(st.Blk(stats, res))(k))
-          case syntax.Ins =>
-            // Implicit instances are not parameterized for now.
-            assert(td.params.isEmpty)
-            subTerm(bod)(r =>
-              Define(ValDefn(td.owner, syntax.ImmutVal, td.sym, r),
-                term_nonTail(st.Blk(stats, res))(k)))
-      case cls: ClassLikeDef if cls.sym.defn.exists(_.isDeclare.isDefined) =>
-        // * Declarations have no lowering
-        term(st.Blk(stats, res))(k)
-      case cls: ClassLikeDef =>
-        reportAnnotations(cls, cls.extraAnnotations)
-        val (mtds, publicFlds, privateFlds, ctor) = gatherMembers(cls.body)
-        cls.ext match
-        case N =>
-          Define(
-            ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, Nil, N,
-              mtds, privateFlds, publicFlds, End(), ctor),
-            term_nonTail(st.Blk(stats, res))(k)
-          )
-        case S(ext) =>
-          assert(k isnt syntax.Mod) // modules can't extend things and can't have super calls
-          subTerm(ext.cls): clsp =>
-            val pctor = // TODO dedup with `New` case
-              args(ext.args): args =>
-                Return(Call(Value.Ref(State.builtinOpsMap("super")), args)(true, true), implct = true)
-            Define(
-              ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, Nil, S(clsp),
-                mtds, privateFlds, publicFlds, pctor, ctor),
-              term_nonTail(st.Blk(stats, res))(k)
-            )
-      case _ =>
-        // TODO handle
-        term(st.Blk(stats, res))(k)
-    case st.Blk((decl @ LetDecl(sym, annotations)) :: (stats @ ((_: DefineVar) :: _)), res) =>
-      reportAnnotations(decl, annotations)
-      term(st.Blk(stats, res))(k)
-    case st.Blk((decl @ LetDecl(sym, annotations)) :: stats, res) =>
-      reportAnnotations(decl, annotations)
-      term(st.Blk(DefineVar(sym, Term.Lit(Tree.UnitLit(false))) :: stats, res))(k)
-    case st.Blk(DefineVar(sym, rhs) :: stats, res) =>
-      val oldSubst = subst
-      rhs match
-      // * This is currently wrong because if `r` is mutable, we can't substitute `sym` with `r`
-      // * TODO: Distinguish mutable from immutable local variables
-      // case Ref(r) =>
-      //   given Subst = oldSubst + (sym -> Value.Ref(r))
-      //   term(st.Blk(stats, res))(k)
-      case _ =>
-        subTerm(rhs): r =>
-          Assign(sym, r, term_nonTail(st.Blk(stats, res))(k))
+    case st.Blk(sts, res) => block(sts, R(res))(k)
     case Assgn(lhs, rhs) =>
       lhs match
       case Ref(sym) =>
@@ -493,13 +511,13 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       subTerm(prefix): p =>
         subTerm_nonTail(fld): f =>
           k(DynSelect(p, f, ai))
-        
+      
 
     case New(cls, as, N) =>
       subTerm(cls): sr =>
         subTerms(as): asr =>
           k(Instantiate(sr, asr))
-        
+      
     case New(cls, as, S((isym, rft))) =>
       subTerm(cls): clsp =>
         val sym = new BlockMemberSymbol(isym.name, Nil)
@@ -510,15 +528,15 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         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))
-    
+      
     case Try(sub, finallyDo) =>
       val l = new TempSymbol(S(sub))
       TryBlock(
         subTerm_nonTail(sub)(p => Assign(l, p, End())),
         subTerm_nonTail(finallyDo)(_ => End()),
         k(Value.Ref(l))
       )
-    
+      
     // * BbML-specific cases: t.Cls#field and mutable operations
     case sp @ SelProj(prefix, _, proj) =>
       setupSelection(prefix, proj, sp.sym)(k)
@@ -536,6 +554,9 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         subTerm_nonTail(rhs): value =>
           AssignField(ref, Tree.Ident("value"), value, k(value))(N)
 
+    case Rcd(stats) =>
+      block(stats, L(Nil))(k)
+    
     case Neg(_) =>
       raise(ErrorReport(
         msg"Unexpected type annotations ${t.show}" ->

hkmc2/shared/src/main/scala/hkmc2/codegen/js/JSBuilder.scala

@@ -144,6 +144,14 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case Value.Arr(es) if es.isEmpty => doc"[]"
     case Value.Arr(es) =>
       doc"[ #{  # ${es.map(argument).mkDocument(doc", # ")} #}  # ]"
+    case Value.Rcd(flds) =>
+      doc"{ #  #{ ${
+        flds.map:
+          case RcdArg(S(idx), v) =>
+            doc"${result(idx)}: ${result(v)}"
+          case RcdArg(N, v) => ???
+        .mkDocument(", ")
+      } #}  # }"
 
   def returningTerm(t: Block, endSemi: Bool)(using Raise, Scope): Document =
     def mkSemi = if endSemi then ";" else ""