Merge remote-tracking branch 'Mark/hkmc2' into feat-llir

Author: waterlens

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

@@ -479,7 +479,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                     case (param, arg) :: args =>
                       val (cse, blk) = mkArgs(args)
                       (cse, Assign(arg, Select(sr, param.id/*FIXME incorrect Ident?*/)(S(param)), blk))
-                  mkMatch(mkArgs(clsParams.zip(args)))
+                  mkMatch(mkArgs(clsParams.iterator.zip(args).collect { case (s1, S(s2)) => (s1, s2) }.toList))
               case Pattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> go(tail, topLevel = false))
         case Split.Else(els) =>
           if k.isInstanceOf[TailOp] && isIf then term_nonTail(els)(k)

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

@@ -621,7 +621,7 @@ trait JSBuilderArgNumSanityChecks(using Config, Elaborator.State)
         doc"\nlet ${nme} = ${paramsStr}[$i];"}.mkDocument("")
       val restAssign = paramRest match
         case N => doc""
-        case S(p) => doc"\nlet $p = globalThis.Predef.tupleSlice($paramsStr, ${params.paramCountLB}, 0);"
+        case S(p) => doc"\nlet $p = runtime.Tuple.slice($paramsStr, ${params.paramCountLB}, 0);"
       (doc"...$paramsStr", doc"$checkArgsNum$paramsAssign$restAssign${this.body(body, endSemi = false)}")
     else
       super.setupFunction(name, params, body)

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

@@ -7,10 +7,22 @@ import ucs.DeBrujinSplit
 
 /** Flat patterns for pattern matching */
 enum Pattern extends AutoLocated:
+  
   case Lit(literal: Literal)
-  case ClassLike(sym: ClassSymbol | ModuleSymbol, trm: Term, parameters: Opt[List[BlockLocalSymbol]], var refined: Bool)(val tree: Tree)
+  
+  /** An individual argument is None when it is not matched, i.e. when an underscore is used there.
+    * The whole argument list is None when no argument list is being matched at all, as in `x is Some then ...`. */
+  case ClassLike(
+    sym: ClassSymbol | ModuleSymbol,
+    trm: Term,
+    args: Opt[List[Opt[BlockLocalSymbol]]],
+    var refined: Bool,
+  )(val tree: Tree)
+  
   case Synonym(symbol: PatternSymbol, patternArguments: Ls[(split: DeBrujinSplit, tree: Tree)])
+  
   case Tuple(size: Int, inf: Bool)
+  
   case Record(entries: List[(Ident -> BlockLocalSymbol)])
 
   def subTerms: Ls[Term] = this match
@@ -22,15 +34,16 @@ enum Pattern extends AutoLocated:
 
   def children: Ls[Located] = this match
     case Lit(literal) => literal :: Nil
-    case ClassLike(_, t, parameters, _) => t :: parameters.toList.flatten
+    case ClassLike(_, t, args, _) =>
+      t :: args.fold(Nil)(_.collect { case S(symbol) => symbol })
     case Synonym(_, arguments) => arguments.map(_.tree)
     case Tuple(fields, _) => Nil
     case Record(entries) => entries.flatMap { case (nme, als) => nme :: als :: Nil }
 
   def showDbg: Str = this match
     case Lit(literal) => literal.idStr
     case ClassLike(sym, t, ps, rfd) => (if rfd then "refined " else "") +
-      sym.nme + ps.fold("")(_.mkString("(", ", ", ")"))
+      sym.nme + ps.fold("")(_.iterator.map(_.fold("_")(_.toString)).mkString("(", ", ", ")"))
     case Synonym(symbol, arguments) =>
       symbol.nme + arguments.iterator.map(_.tree.showDbg).mkString("(", ", ", ")")
     case Tuple(size, inf) => "[]" + (if inf then ">=" else "=") + size

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

@@ -347,7 +347,7 @@ extension (split: DeBrujinSplit)
                   go(body, ctx2)
               val select = scoped("ucs:sel"):
                 elab.reference(symbol).getOrElse(Term.Error)
-              val pattern = Pattern.ClassLike(symbol, select, S(subSymbols), false)(Empty())
+              val pattern = Pattern.ClassLike(symbol, select, S(subSymbols.map(S.apply)), false)(Empty())
               semantics.Branch(ctx(scrutinee - 1)(), pattern, consequent2) ~: go(alternative, ctx)
             case ClassLike(ConstructorLike.Symbol(symbol: ModuleSymbol)) =>
               val select = scoped("ucs:sel"):

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

@@ -11,6 +11,7 @@ import Keyword.{as, and, `do`, `else`, is, let, `then`}
 import collection.mutable.{HashMap, SortedSet}
 import Elaborator.{ctx, Ctxl}
 import scala.annotation.targetName
+import hkmc2.semantics.ClassDef.Parameterized
 
 object Desugarer:
   extension (op: Keyword.Infix)
@@ -478,19 +479,27 @@ class Desugarer(val elaborator: Elaborator)
       val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
       clsTrm.symbol.flatMap(_.asClsLike) match
       case S(cls: ClassSymbol) =>
-        val arity = cls.arity
-        if arity =/= args.length then
-          val m = args.length.toString
-          error:
-            if arity == 0 then
-              msg"the constructor does not take any arguments but found $m" -> app.toLoc
-            else
-              msg"mismatched arity: expect ${arity.toString}, found $m" -> app.toLoc
-        val params = scrutSymbol.getSubScrutinees(cls)
+        val paramSymbols = cls.defn match
+          case S(Parameterized(params = paramList)) =>
+            if paramList.params.size =/= args.length then
+              val n = args.length.toString
+              val m = paramList.params.size.toString
+              error:
+                if paramList.params.isEmpty then
+                  msg"the constructor does not take any arguments but found $n" -> app.toLoc
+                else
+                  msg"mismatched arity: expect $m, found $n" -> app.toLoc
+            scrutSymbol.getSubScrutinees(cls).iterator.zip(paramList.params).map:
+              case (symbol, Param(flags = FldFlags(value = true))) => R(symbol)
+              case (_, Param(_, paramSymbol, _)) => L(paramSymbol) // to report errors
+            .toList
+          case S(_) | N =>
+            error(msg"class ${cls.name} does not have parameters" -> ctor.toLoc)
+            Nil
         Branch(
           ref,
-          Pattern.ClassLike(cls, clsTrm, S(params), false)(ctor), // TODO: refined?
-          subMatches(params zip args, sequel)(Split.End)(ctx)
+          Pattern.ClassLike(cls, clsTrm, S(paramSymbols.map(_.toOption)), false)(ctor), // TODO: refined?
+          subMatches(paramSymbols.zip(args), sequel)(Split.End)(ctx)
         ) ~: fallback
       case S(pat: PatternSymbol) if compile =>
         // When we support extraction parameters, they need to be handled here.
@@ -550,26 +559,26 @@ class Desugarer(val elaborator: Elaborator)
         val (wrapRest, restMatches) = rest match
           case S((rest, last)) =>
             val (wrapLast, reversedLastMatches) = last.reverseIterator.zipWithIndex
-              .foldLeft[(Split => Split, Ls[(BlockLocalSymbol, Tree)])]((identity, Nil)):
+              .foldLeft[(Split => Split, Ls[(Right[Nothing, BlockLocalSymbol], Tree)])]((identity, Nil)):
                 case ((wrapInner, matches), (pat, lastIndex)) =>
                   val sym = scrutSymbol.getTupleLastSubScrutinee(lastIndex)
                   val wrap = (split: Split) =>
                     Split.Let(sym, callTupleGet(ref, -1 - lastIndex, sym), wrapInner(split))
-                  (wrap, (sym, pat) :: matches)
+                  (wrap, (R(sym), pat) :: matches)
             val lastMatches = reversedLastMatches.reverse
             rest match
               case N => (wrapLast, lastMatches)
               case S(pat) =>
                 val sym = TempSymbol(N, "rest")
                 val wrap = (split: Split) =>
                   Split.Let(sym, app(tupleSlice, tup(fld(ref), fld(int(lead.length)), fld(int(last.length))), sym), wrapLast(split))
-                (wrap, (sym, pat) :: lastMatches)
+                (wrap, (R(sym), pat) :: lastMatches)
           case N => (identity: Split => Split, Nil)
         val (wrap, matches) = lead.zipWithIndex.foldRight((wrapRest, restMatches)):
           case ((pat, i), (wrapInner, matches)) =>
             val sym = scrutSymbol.getTupleLeadSubScrutinee(i)
             val wrap = (split: Split) => Split.Let(sym, Term.SynthSel(ref, Ident(s"$i"))(N), wrapInner(split))
-            (wrap, (sym, pat) :: matches)
+            (wrap, (R(sym), pat) :: matches)
         Branch(
           ref,
           Pattern.Tuple(lead.length + rest.fold(0)(_._2.length), rest.isDefined),
@@ -609,16 +618,29 @@ class Desugarer(val elaborator: Elaborator)
   /** Desugar a list of sub-patterns (with their corresponding scrutinees).
    *  This is called when handling nested patterns. The caller is responsible
    *  for providing the symbols of scrutinees.
+   * 
+   *  @param matches a list of pairs consisting of a scrutinee and a pattern.
+   *    Each scrutinee is represented by `Either[VarSymbol, BlockLocalSymbol]`.
+   *    If it is not accessible due to the corresponding parameter not being
+   *    declared with `val`, it will be the `Left` of the parameter symbol for
+   *    error reporting.
+   *  @param sequel the innermost split
    */
-  def subMatches(matches: Ls[(BlockLocalSymbol, Tree)],
+  def subMatches(matches: Ls[(Either[VarSymbol, BlockLocalSymbol], Tree)],
                  sequel: Sequel): Split => Sequel = matches match
     case Nil => _ => ctx => trace(
       pre = s"subMatches (done) <<< Nil",
       post = (r: Split) => s"subMatches >>> ${r.showDbg}"
     ):
       sequel(ctx)
     case (_, Under()) :: rest => subMatches(rest, sequel)
-    case (scrutinee, pattern) :: rest => fallback => trace(
+    case (L(paramSymbol), pattern) :: rest =>
+      error(msg"This pattern cannot be matched" -> pattern.toLoc,
+        msg"because the corresponding parameter `${paramSymbol.name}` is not publicly accessible" -> paramSymbol.toLoc,
+        msg"Suggestion: use a wildcard pattern `_` in this position" -> N,
+        msg"Suggestion: mark this parameter with `val` so it becomes accessible" -> N)
+      subMatches(rest, sequel)
+    case (R(scrutinee), pattern) :: rest => fallback => trace(
       pre = s"subMatches (nested) <<< $scrutinee is $pattern",
       post = (r: Sequel) => s"subMatches (nested) >>>"
     ):

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

@@ -9,7 +9,7 @@ import syntax.Tree.*, Elaborator.{Ctxl, ctx}, Elaborator.State
 trait DesugaringBase(using state: State):
   val elaborator: Elaborator
 
-  import elaborator.tl.*, state.globalThisSymbol
+  import elaborator.tl.*
 
   protected final def sel(p: Term, k: Ident): Term.SynthSel = Term.SynthSel(p, k)(N)
   protected final def sel(p: Term, k: Ident, s: FieldSymbol): Term.SynthSel = Term.SynthSel(p, k)(S(s))
@@ -22,54 +22,50 @@ trait DesugaringBase(using state: State):
   protected final def app(l: Term, r: Term, label: Str): Term.App = app(l, r, FlowSymbol(label))
   protected final def app(l: Term, r: Term, s: FlowSymbol): Term.App = Term.App(l, r)(App(Empty(), Empty()), s)
 
-  /** Make a term looks like `globalThis.Predef.MatchResult` with its symbol. */
+  /** Make a term that looks like `runtime.MatchResult` with its symbol. */
   protected lazy val matchResultClass: Ctxl[(Term.Sel | Term.SynthSel, ClassSymbol)] =
     (State.runtimeSymbol.ref().selNoSym("MatchResult", synth=true), State.matchResultClsSymbol)
 
-  /** Make a pattern looks like `globalThis.Predef.MatchResult.class`. */
+  /** Make a pattern that looks like `runtime.MatchResult.class`. */
   protected def matchResultPattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
     val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
-    Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
+    Pattern.ClassLike(classSym, classSel, parameters.map(_.map(S.apply)), false)(Empty())
 
-  /** Make a term looks like `globalThis.Predef.MatchFailure` with its symbol. */
+  /** Make a term that looks like `runtime.MatchFailure` with its symbol. */
   protected lazy val matchFailureClass: Ctxl[(Term.Sel | Term.SynthSel, ClassSymbol)] =
     (State.runtimeSymbol.ref().selNoSym("MatchFailure", synth=true), State.matchFailureClsSymbol)
 
-  /** Make a pattern looks like `globalThis.Predef.MatchFailure.class`. */
+  /** Make a pattern that looks like `runtime.MatchFailure.class`. */
   protected def matchFailurePattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
     val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
-    Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
+    Pattern.ClassLike(classSym, classSel, parameters.map(_.map(S.apply)), false)(Empty())
 
-  /** Create a term that selects a method in the `Predef` module. */
-  protected final def selectPredefMethod =
-    sel(sel(globalThisSymbol.ref(), "Predef"), _: Str)
+  protected lazy val tupleSlice = sel(sel(state.runtimeSymbol.ref(), "Tuple"), "slice")
+  protected lazy val tupleGet = sel(sel(state.runtimeSymbol.ref(), "Tuple"), "get")
+  protected lazy val stringStartsWith = sel(sel(state.runtimeSymbol.ref(), "Str"), "startsWith")
+  protected lazy val stringGet = sel(sel(state.runtimeSymbol.ref(), "Str"), "get")
+  protected lazy val stringDrop = sel(sel(state.runtimeSymbol.ref(), "Str"), "drop")
 
-  protected lazy val tupleSlice = selectPredefMethod("tupleSlice")
-  protected lazy val tupleGet = selectPredefMethod("tupleGet")
-  protected lazy val stringStartsWith = selectPredefMethod("stringStartsWith")
-  protected lazy val stringGet = selectPredefMethod("stringGet")
-  protected lazy val stringDrop = selectPredefMethod("stringDrop")
-
-  /** Make a term that looks like `tupleGet(t, i)`. */
+  /** Make a term that looks like `runtime.Tuple.get(t, i)`. */
   protected final def callTupleGet(t: Term, i: Int, label: Str): Ctxl[Term] =
     callTupleGet(t, i, FlowSymbol(label))
 
-  /** Make a term that looks like `tupleGet(t, i)`. */
+  /** Make a term that looks like `runtime.Tuple.slice(t, i)`. */
   protected final def callTupleGet(t: Term, i: Int, s: FlowSymbol): Ctxl[Term] =
     app(tupleGet, tup(fld(t), fld(int(i))), s)
 
-  /** Make a term that looks like `stringStartsWith(t, p)`. */
-  protected final def callStringStartsWith(t: Term, p: Term, label: Str): Ctxl[Term] =
+  /** Make a term that looks like `runtime.Str.startsWith(t, p)`. */
+  protected final def callStringStartsWith(t: Term.Ref, p: Term, label: Str): Ctxl[Term] =
     app(stringStartsWith, tup(fld(t), fld(p)), FlowSymbol(label))
 
-  /** Make a term that looks like `stringStartsWith(t, i)`. */
-  protected final def callStringGet(t: Term, i: Int, label: Str): Ctxl[Term] =
+  /** Make a term that looks like `runtime.Str.get(t, i)`. */
+  protected final def callStringGet(t: Term.Ref, i: Int, label: Str): Ctxl[Term] =
     app(stringGet, tup(fld(t), fld(int(i))), FlowSymbol(label))
 
-  /** Make a term that looks like `stringStartsWith(t, n)`. */
-  protected final def callStringDrop(t: Term, n: Int, label: Str): Ctxl[Term] =
+  /** Make a term that looks like `runtime.Str.drop(t, n)`. */
+  protected final def callStringDrop(t: Term.Ref, n: Int, label: Str): Ctxl[Term] =
     app(stringDrop, tup(fld(t), fld(int(n))), FlowSymbol(label))
 
   protected final def tempLet(dbgName: Str, term: Term)(inner: TempSymbol => Split): Split =

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

@@ -46,7 +46,7 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
     def =:=(rhs: Pattern): Bool = (lhs, rhs) match
       case (c1: Pattern.ClassLike, c2: Pattern.ClassLike) => c1.sym === c2.sym
       case (Pattern.Lit(l1), Pattern.Lit(l2)) => l1 === l2
-      case (Pattern.Tuple(n1, b1), Pattern.Tuple(n2, b2)) => n1 == n2 && b1 == b2
+      case (Pattern.Tuple(n1, b1), Pattern.Tuple(n2, b2)) => n1 === n2 && b1 === b2
       case (_, _) => false
     /** Checks if `lhs` can be subsumed under `rhs`. */
     def <:<(rhs: Pattern): Bool = compareCasePattern(lhs, rhs)
@@ -223,8 +223,9 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
   private def aliasBindings(p: Pattern, q: Pattern): Split => Split = (p, q) match
     case (Pattern.ClassLike(_, _, S(ps1), _), Pattern.ClassLike(_, _, S(ps2), _)) =>
       ps1.iterator.zip(ps2.iterator).foldLeft(identity[Split]):
-        case (acc, (p1, p2)) if p1 == p2 => acc
-        case (acc, (p1, p2)) => innermost => Split.Let(p2, p1.ref(), acc(innermost))
+        case (acc, (S(p1), S(p2))) if p1 === p2 => acc
+        case (acc, (S(p1), S(p2))) => innermost => Split.Let(p2, p1.ref(), acc(innermost))
+        case (acc, (_, _)) => acc
     case (_, _) => identity
 end Normalization
 
@@ -240,7 +241,7 @@ object Normalization:
     case (ClassLike(cs: ClassSymbol, _, _, _), ClassLike(blt.`Object`, _, _, _))
         if !ctx.builtins.virtualClasses.contains(cs) => true
     case (ClassLike(cs: ModuleSymbol, _, _, _), ClassLike(blt.`Object`, _, _, _)) => true
-    case (Tuple(n1, false), Tuple(n2, false)) if n1 == n2 => true
+    case (Tuple(n1, false), Tuple(n2, false)) if n1 === n2 => true
     case (Tuple(n1, _), Tuple(n2, true)) if n2 <= n1 => true
     case (ClassLike(`Int`, _, _, _), ClassLike(blt.`Num`, _, _, _)) => true
     // case (s1: ClassSymbol, s2: ClassSymbol) => s1 <:< s2 // TODO: find a way to check inheritance

hkmc2/shared/src/test/mlscript-compile/Predef.mjs

@@ -150,32 +150,24 @@ let Predef1;
   static tuple(...xs1) {
     return xs1
   } 
-  static tupleSlice(xs2, i, j) {
-    let tmp;
-    tmp = xs2.length - j;
-    return runtime.safeCall(globalThis.Array.prototype.slice.call(xs2, i, tmp))
-  } 
-  static tupleGet(xs3, i1) {
-    return globalThis.Array.prototype.at.call(xs3, i1)
-  } 
   static foldr(f9) {
     return (first, ...rest) => {
-      let len, i2, init, scrut, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5;
+      let len, i, init, scrut, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5;
       len = rest.length;
       scrut1 = len == 0;
       if (scrut1 === true) {
         return first
       } else {
         tmp = len - 1;
-        i2 = tmp;
-        tmp1 = runtime.safeCall(rest.at(i2));
+        i = tmp;
+        tmp1 = runtime.safeCall(rest.at(i));
         init = tmp1;
         tmp6: while (true) {
-          scrut = i2 > 0;
+          scrut = i > 0;
           if (scrut === true) {
-            tmp2 = i2 - 1;
-            i2 = tmp2;
-            tmp3 = runtime.safeCall(rest.at(i2));
+            tmp2 = i - 1;
+            i = tmp2;
+            tmp3 = runtime.safeCall(rest.at(i));
             tmp4 = runtime.safeCall(f9(tmp3, init));
             init = tmp4;
             tmp5 = runtime.Unit;
@@ -189,7 +181,7 @@ let Predef1;
       }
     }
   } 
-  static mkStr(...xs4) {
+  static mkStr(...xs2) {
     let tmp, tmp1, lambda;
     lambda = (undefined, function (acc, x7) {
       let tmp2, tmp3, tmp4;
@@ -204,16 +196,7 @@ let Predef1;
     });
     tmp = lambda;
     tmp1 = runtime.safeCall(Predef.fold(tmp));
-    return runtime.safeCall(tmp1(...xs4))
-  } 
-  static stringStartsWith(string, prefix) {
-    return runtime.safeCall(string.startsWith(prefix))
-  } 
-  static stringGet(string1, i2) {
-    return runtime.safeCall(string1.at(i2))
-  } 
-  static stringDrop(string2, n) {
-    return runtime.safeCall(string2.slice(n))
+    return runtime.safeCall(tmp1(...xs2))
   } 
   static get unreachable() {
     throw globalThis.Error("unreachable");

hkmc2/shared/src/test/mlscript-compile/Predef.mls

@@ -50,15 +50,6 @@ fun (???) notImplementedError = throw Error("Not implemented")
 
 fun tuple(...xs) = xs
 
-fun tupleSlice(xs, i, j) =
-  // * This is more robust than `xs.slice(i, xs.length - j)`
-  // * as it is not affected by users redefining `slice`
-  globalThis.Array.prototype.slice.call(xs, i, xs.length - j)
-
-fun tupleGet(xs, i) =
-  // * Contrary to `xs.[i]`, this supports negative indices (Python-style)
-  globalThis.Array.prototype.at.call(xs, i)
-
 val foldl = fold
 
 // fun foldr(f)(...rest, init) = // TODO allow this syntax
@@ -78,13 +69,6 @@ fun mkStr(...xs) =
   fold((acc, x) => assert(x is Str); acc + x) of ...xs
 
 
-fun stringStartsWith(string, prefix) = string.startsWith(prefix)
-
-fun stringGet(string, i) = string.at(i)
-
-fun stringDrop(string, n) = string.slice(n)
-
-
 fun unreachable = throw Error("unreachable")
 
 fun checkArgs(functionName, expected, isUB, got) =