merge fom hkmc2

Author: CAG2Mark

.github/workflows/scala.yml

@@ -24,4 +24,6 @@ jobs:
     - name: Run tests
       run: sbt -J-Xmx4096M -J-Xss4M test
     - name: Check no changes
-      run: git diff-files -p --exit-code
+      run: |
+        git update-index -q --refresh
+        git diff-files -p --exit-code

build.sbt

@@ -2,7 +2,7 @@ import Wart._
 
 enablePlugins(ScalaJSPlugin)
 
-val scala3Version = "3.5.1"
+val scala3Version = "3.5.2"
 val directoryWatcherVersion = "0.18.0"
 
 ThisBuild / scalaVersion     := "2.13.13"

hkmc2/jvm/src/test/scala/hkmc2/DiffTestRunner.scala

@@ -55,8 +55,9 @@ object DiffTestRunner:
         else if filePath.ext =/= "mls" then N
         else S(filePath)
       }.toSet catch
-        case err: Throwable => System.err.println("/!\\ git command failed with: " + err)
-        Set.empty
+        case err: Throwable =>
+          System.err.println("/!\\ git command failed with: " + err)
+          Set.empty
 
   end State
 
@@ -82,7 +83,7 @@ abstract class DiffTestRunner(state: DiffTestRunner.State)
         "\n\tNote: you can increase this limit by changing DiffTests.TimeLimit")
       // * Thread.stop() is considered bad practice because normally it's better to implement proper logic
       // * to terminate threads gracefully, avoiding leaving applications in a bad state.
-      // * But here we DGAF since all the test is doing is runnign a type checker and some Node REPL,
+      // * But here we DGAF since all the test is doing is running a type checker and some Node REPL,
       // * which would be a much bigger pain to make receptive to "gentle" interruption.
       // * It would feel extremely wrong to intersperse the pure type checker algorithms
       // * with ugly `Thread.isInterrupted` checks everywhere...

hkmc2/jvm/src/test/scala/hkmc2/JSBackendDiffMaker.scala

@@ -12,6 +12,7 @@ abstract class JSBackendDiffMaker extends MLsDiffMaker:
   val js = NullaryCommand("js")
   val sjs = NullaryCommand("sjs")
   val showRepl = NullaryCommand("showRepl")
+  val silent = NullaryCommand("silent")
 
   private val baseScp: codegen.js.Scope =
     codegen.js.Scope.empty
@@ -61,17 +62,18 @@ abstract class JSBackendDiffMaker extends MLsDiffMaker:
         output(jsStr)
       def mkQuery(prefix: Str, jsStr: Str) =
         val queryStr = jsStr.replaceAll("\n", " ")
-        val (reply, stderr) = host.query(queryStr)
+        val (reply, stderr) = host.query(queryStr, expectRuntimeErrors.isUnset && fixme.isUnset && todo.isUnset)
         reply match
           case ReplHost.Result(content, stdout) =>
-            stdout match
-              case None | Some("") =>
-              case Some(str) =>
-                str.splitSane('\n').foreach: line =>
-                  output(s"> ${line}")
-            content match
-            case "undefined" =>
-            case _ => output(s"$prefix= ${content}")
+            if silent.isUnset then
+              stdout match
+                case None | Some("") =>
+                case Some(str) =>
+                  str.splitSane('\n').foreach: line =>
+                    output(s"> ${line}")
+              content match
+              case "undefined" =>
+              case _ => output(s"$prefix= ${content}")
           case ReplHost.Empty =>
           case ReplHost.Unexecuted(message) => ???
           case ReplHost.Error(isSyntaxError, message) =>

hkmc2/jvm/src/test/scala/hkmc2/ReplHost.scala

@@ -98,10 +98,10 @@ class ReplHost(using TL) {
     stdin.write(if code.endsWith("\n") then code else code + "\n")
     stdin.flush()
 
-  def query(code: Str): (ReplHost.Reply, Str) =
+  def query(code: Str, showStackTrace: Bool): (ReplHost.Reply, Str) =
     // Wrap the code with `try`-`catch` block.
     val wrapped =
-      s"try { $code } catch (e) { console.log('\\u200B' + e + '\\u200B'); }"
+      s"try { $code } catch (e) { console.log('\\u200B' + ${if showStackTrace then "e.stack" else "e"} + '\\u200B'); }"
     // Send the code
     send(wrapped)
     (parseQueryResult() match

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

@@ -287,7 +287,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       val res = freshVar(using ctx)
       constrain(bodyCtx, sk | res)
       (bodyTy, rhsCtx | res, rhsEff | bodyEff)
-    case Term.If(Split.Cons(Branch(cond, Pattern.LitPat(BoolLit(true)), Split.Else(cons)), Split.Else(alts))) =>
+    case Term.IfLike(Keyword.`if`, Split.Cons(Branch(cond, Pattern.LitPat(BoolLit(true)), Split.Else(cons)), Split.Else(alts))) =>
       val (condTy, condCtx, condEff) = typeCode(cond)
       val (consTy, consCtx, consEff) = typeCode(cons)
       val (altsTy, altsCtx, altsEff) = typeCode(alts)
@@ -347,7 +347,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
     case Split.Else(alts) => sign match
       case S(sign) => ascribe(alts, sign)
       case _ => typeCheck(alts)
-    case Split.Nil => ???
+    case Split.End => ???
 
   // * Note: currently, the returned type is not used or useful, but it could be in the future
   private def ascribe(lhs: Term, rhs: GeneralType)(using ctx: Ctx): (GeneralType, Type) =
@@ -373,7 +373,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       given Ctx = nextCtx
       constrain(ascribe(term, skolemize(pt))._2, Bot) // * never generalize terms with effects
       (pt, Bot)
-    case (Term.If(branches), ty) => // * propagate
+    case (Term.IfLike(Keyword.`if`, branches), ty) => // * propagate
       typeSplit(branches, S(ty))
     case (Term.Asc(term, ty), rhs) =>
       ascribe(term, typeType(ty))
@@ -448,11 +448,11 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
             effBuff += eff
             nestCtx += sym -> rhsTy
             goStats(stats)
-          case TermDefinition(Fun, sym, params, sig, Some(body), _) :: stats =>
-            typeFunDef(sym, params match {
-              case S(params) => Term.Lam(params, body)
-              case _ => body // * may be a case expressions
-            }, sig, ctx)
+          case TermDefinition(Fun, sym, ParamList(_, ps) :: Nil, sig, Some(body), _) :: stats =>
+            typeFunDef(sym, Term.Lam(ps, body), sig, ctx)
+            goStats(stats)
+          case TermDefinition(Fun, sym, Nil, sig, Some(body), _) :: stats =>
+            typeFunDef(sym, body, sig, ctx)  // * may be a case expressions
             goStats(stats)
           case TermDefinition(Fun, sym, _, S(sig), None, _) :: stats =>
             ctx += sym -> typeType(sig)
@@ -536,7 +536,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       case Term.Asc(term, ty) =>
         val res = typeType(ty)(using ctx)
         ascribe(term, res)
-      case Term.If(branches) => typeSplit(branches, N)
+      case Term.IfLike(Keyword.`if`, branches) => typeSplit(branches, N)
       case Term.Region(sym, body) =>
         val nestCtx = ctx.nextLevel
         given Ctx = nestCtx

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

@@ -32,8 +32,10 @@ sealed abstract class Block extends Product with AutoLocated:
     case Match(scrut, arms, dflt, rst) =>
       arms.flatMap(_._2.definedVars).toSet ++ dflt.toList.flatMap(_.definedVars) ++ rst.definedVars
     case End(_) => Set.empty
+    case Break(_, _) => Set.empty
     case Define(defn, rst) => rst.definedVars
     case TryBlock(sub, fin, rst) => sub.definedVars ++ fin.definedVars ++ rst.definedVars
+    case Label(lbl, bod, rst) => bod.definedVars ++ rst.definedVars
 
   // TODO conserve if no changes
   def mapTail(f: BlockTail => BlockTail): Block = this match
@@ -60,6 +62,11 @@ case class Return(res: Result, implct: Bool) extends BlockTail
 
 case class Throw(exc: Result) extends BlockTail
 
+case class Label(label: Local, body: Block, rest: Block) extends BlockTail
+
+case class Break(label: Local, toBeginning: Bool) extends BlockTail
+
+// TODO: remove this form?
 case class Begin(sub: Block, rest: Block) extends Block with ProductWithTail
 
 case class TryBlock(sub: Block, finallyDo: Block, rest: Block) extends Block with ProductWithTail
@@ -74,7 +81,7 @@ sealed abstract class Defn:
 final case class TermDefn(
     k: syntax.TermDefKind,
     sym: TermSymbol,
-    params: Opt[Ls[Param]],
+    params: Ls[ParamList],
     body: Block,
 ) extends Defn
 

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

@@ -51,10 +51,14 @@ class Lowering(using TL, Raise, Elaborator.State):
       k(Value.Lit(lit))
     case st.Ret(res) =>
       returnedTerm(res)
+    case st.Asc(lhs, rhs) =>
+      term(lhs)(k)
     case st.Tup(fs) =>
       fs.foldRight[Ls[Path] => Block](args => k(Value.Arr(args.reverse)))((a, acc) =>
         args => subTerm(a.value)(r => acc(r :: args))
       )(Nil)
+    case st.This(sym) =>
+      k(subst(Value.This(sym)))
     case st.Ref(sym) =>
       sym match
       case sym: LocalSymbol =>
@@ -101,6 +105,8 @@ class Lowering(using TL, Raise, Elaborator.State):
         TODO("Other argument list forms")
 
     case st.Blk(Nil, res) => term(res)(k)
+    case st.Blk(Lit(Tree.UnitLit(true)) :: stats, res) =>
+      subTerm(st.Blk(stats, res))(k)
     case st.Blk((p @ (_: Ref | _: Lit)) :: stats, res) =>
       raise(WarningReport(msg"Pure expression in statement position" -> p.toLoc :: Nil))
       subTerm(st.Blk(stats, res))(k)
@@ -200,52 +206,69 @@ class Lowering(using TL, Raise, Elaborator.State):
             )
     */
 
-    case iftrm: st.If =>
+    case iftrm: st.IfLike =>
+      
+      tl.log(s"${iftrm.kw} $iftrm")
 
-      tl.log(s"If $iftrm")
+      val isIf = iftrm.kw match
+        case syntax.Keyword.`if` => true
+        case syntax.Keyword.`while` => false
+      val isWhile = !isIf
 
       var usesResTmp = false
       lazy val l =
         usesResTmp = true
         new TempSymbol(summon[Elaborator.State].nextUid, S(t))
 
-      def go(split: Split)(using Subst): Block = split match
+      lazy val lbl =
+        new TempSymbol(summon[Elaborator.State].nextUid, S(t))
+      
+      def go(split: Split, topLevel: Bool)(using Subst): Block = split match
         case Split.Let(sym, trm, tl) =>
           term(trm): r =>
-            Assign(sym, r, go(tl))
+            Assign(sym, r, go(tl, topLevel))
         case Split.Cons(Branch(scrut, pat, tail), restSplit) =>
           subTerm(scrut): sr =>
             tl.log(s"Binding scrut $scrut to $sr ${summon[Subst].map}")
             val cse = pat match
-              case Pattern.LitPat(lit) => Case.Lit(lit) -> go(tail)
+              case Pattern.LitPat(lit) => Case.Lit(lit) -> go(tail, topLevel = false)
               case Pattern.Class(cls, args0, _refined) =>
                 val args = args0.getOrElse(Nil)
                 val clsDefn = cls.defn.getOrElse(die)
                 val clsParams = clsDefn.paramsOpt.getOrElse(Nil)
                 assert(args0.isEmpty || clsParams.length === args.length)
                 def mkArgs(args: Ls[Param -> BlockLocalSymbol])(using Subst): Case -> Block = args match
-                  case Nil => Case.Cls(cls) -> go(tail)
+                  case Nil => Case.Cls(cls) -> go(tail, topLevel = false)
                   case (param, arg) :: args =>
                     // summon[Subst].+(arg -> Value.Ref(new TempSymbol(summon[Elaborator.State].nextUid, N)))
                     // Assign(arg, Select(sr, Tree.Ident("head")), mkArgs(args))
                     val (cse, blk) = mkArgs(args)
                     (cse, Assign(arg, Select(sr, param.sym.id/*FIXME incorrect Ident?*/), blk))
                 mkArgs(clsParams.zip(args))
             Match(sr, cse :: Nil,
-              // elseBranch,
-              S(go(restSplit)),
+              S(go(restSplit, topLevel = true)),
               End()
             )
         case Split.Else(els) =>
-          if k.isInstanceOf[Ret] then term(els)(k)
-          else term(els)(r => Assign(l, r, End()))
-        case Split.Nil =>
+          if k.isInstanceOf[Ret] && isIf then term(els)(k)
+          else
+            term(els): r =>
+              Assign(l, r,
+                if isWhile && !topLevel then Break(lbl, toBeginning = true)
+                // if isWhile then Break(lbl, toBeginning = !topLevel)
+                else End()
+              )
+        case Split.End =>
           Throw(Instantiate(Value.Ref(Elaborator.Ctx.errorSymbol),
             Value.Lit(syntax.Tree.StrLit("match error")) :: Nil)) // TODO add failed-match scrutinee info
 
-      if k.isInstanceOf[Ret] then go(iftrm.normalized)
-      else Begin(
-          go(iftrm.normalized),
+      if k.isInstanceOf[Ret] && isIf then go(iftrm.normalized, topLevel = true)
+      else
+        val body = if isWhile
+          then Label(lbl, go(iftrm.normalized, topLevel = true), End())
+          else go(iftrm.normalized, topLevel = true)
+        Begin(
+          body,
           if usesResTmp then k(Value.Ref(l))
           else k(Value.Lit(syntax.Tree.UnitLit(true))) // * it seems this currently never happens
         )

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

@@ -12,6 +12,9 @@ import hkmc2.semantics.Elaborator
 import hkmc2.syntax.Tree
 import hkmc2.semantics.TopLevelSymbol
 import hkmc2.semantics.MemberSymbol
+import hkmc2.semantics.ParamList
+import hkmc2.codegen.Value.Lam
+import hkmc2.semantics.ImportedSymbol
 
 
 // TODO factor some logic for other codegen backends
@@ -57,6 +60,8 @@ class JSBuilder extends CodeBuilder:
         doc"${result(Value.This(owner))}.${ts.id.name}"
       case N =>
         ts.id.name
+    case imp: ImportedSymbol =>
+      doc"${getVar(imp.base)}.${imp.id.name}"
     case _ => summon[Scope].lookup_!(l)
 
   def result(r: Result)(using Raise, Scope): Document = r match
@@ -99,11 +104,14 @@ class JSBuilder extends CodeBuilder:
         result(Value.This(sym))
       val (thisProxy, res) = scope.nestRebindThis(defn.sym):
         val defnJS = defn match
-        case TermDefn(syntax.Fun, sym, N, body) =>
+        case TermDefn(syntax.Fun, sym, Nil, body) =>
           TODO("getters")
-        case TermDefn(syntax.Fun, sym, S(ps), bod) =>
-          val vars = ps.map(p => scope.allocateName(p.sym)).mkDocument(", ")
-          doc"function ${sym.nme}($vars) { #{  # ${body(bod)} #}  # }"
+        case TermDefn(syntax.Fun, sym, ParamList(_, ps) :: pss, bod) =>
+          val paramList = ps.map(p => scope.allocateName(p.sym)).mkDocument(", ")
+          val result = pss.foldRight(bod):
+            case (ParamList(_, ps), block) => 
+              Return(Lam(ps, block), false)
+          doc"function ${sym.nme}(${paramList}) { #{  # ${body(result)} #}  # }"
         case ClsDefn(sym, syntax.Cls, mtds, flds, ctor) =>
           val clsDefn = sym.defn.getOrElse(die)
           val clsParams = clsDefn.paramsOpt.getOrElse(Nil)
@@ -118,11 +126,12 @@ class JSBuilder extends CodeBuilder:
           }) { #{  # ${
             ctorCode.stripBreaks
           } #}  # }${
-            mtds.map: td =>
-              val vars = td.params.getOrElse(Nil).map(p => scope.allocateName(p.sym)).mkDocument(", ")
-              doc" # ${td.sym.nme}($vars) { #{  # ${
-                body(td.body)
-              } #}  # }"
+            mtds.map: 
+              case td @ TermDefn(_, _, ParamList(_, ps) :: Nil, _) =>
+                val vars = ps.map(p => scope.allocateName(p.sym)).mkDocument(", ")
+                doc" # ${td.sym.nme}($vars) { #{  # ${
+                  body(td.body)
+                } #}  # }"
             .mkDocument(" ")
           }${
             if mtds.exists(_.sym.nme == "toString")
@@ -194,6 +203,18 @@ class JSBuilder extends CodeBuilder:
 
     case Throw(res) =>
       doc" # throw ${result(res)}"
+    
+    case Break(lbl, false) =>
+      doc" # break ${getVar(lbl)}"
+    
+    case Break(lbl, true) =>
+      doc" # continue ${getVar(lbl)}"
+    
+    case Label(lbl, bod, rst) =>
+      scope.allocateName(lbl)
+      doc" # ${getVar(lbl)}: while (true) { #{ ${
+        returningTerm(bod)
+      } # break; #}  # }${returningTerm(rst)}"
 
     case TryBlock(sub, fin, rst) =>
       doc" # try { #{ ${returningTerm(sub)