Merge branch 'hkmc2' into move-implicit-resolution

Author: FlandiaYingman

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

@@ -58,7 +58,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   val lift: Bool = config.liftDefns.isDefined
 
   private lazy val unreachableFn =
-    Select(Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Predef"))(N), Tree.Ident("unreachable"))(N)
+    Select(Value.Ref(State.runtimeSymbol), Tree.Ident("unreachable"))(N)
 
   def unit: Path =
     Select(Value.Ref(State.runtimeSymbol), Tree.Ident("Unit"))(S(summon[Ctx].builtins.Unit))
@@ -762,9 +762,9 @@ trait LoweringTraceLog(instrument: Bool)(using TL, Raise, State)
   extension (k: Block => Block)
     def |>: (b: Block): Block = k(b)
 
-  private val traceLogFn = selFromGlobalThis("Predef", "TraceLogger", "log")
-  private val traceLogIndentFn = selFromGlobalThis("Predef", "TraceLogger", "indent")
-  private val traceLogResetFn = selFromGlobalThis("Predef", "TraceLogger", "resetIndent")
+  private val traceLogFn = Value.Ref(State.runtimeSymbol).selSN("TraceLogger").selSN("log")
+  private val traceLogIndentFn = Value.Ref(State.runtimeSymbol).selSN("TraceLogger").selSN("indent")
+  private val traceLogResetFn = Value.Ref(State.runtimeSymbol).selSN("TraceLogger").selSN("resetIndent")
   private val strConcatFn = selFromGlobalThis("String", "prototype", "concat", "call")
   private val inspectFn = selFromGlobalThis("util", "inspect")
 

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

@@ -23,6 +23,7 @@ abstract class CodeBuilder:
 
 
 class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
+  import JSBuilder.*
 
   def checkMLsCalls: Bool = false
   def checkSelections: Bool = false
@@ -76,6 +77,8 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       else summon[Scope].findThis_!(ts)
     case _ => summon[Scope].lookup_!(l)
 
+  def runtimeVar(using Raise, Scope): Document = getVar(State.runtimeSymbol)
+  
   def argument(a: Arg)(using Raise, Scope): Document =
     if a.spread then doc"...${result(a.value)}" else result(a.value)
 
@@ -94,7 +97,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
 
   def result(r: Result)(using Raise, Scope): Document = r match
     case Value.This(sym) => summon[Scope].findThis_!(sym)
-    case Value.Lit(Tree.StrLit(value)) => JSBuilder.makeStringLiteral(value)
+    case Value.Lit(Tree.StrLit(value)) => makeStringLiteral(value)
     case Value.Lit(lit) => lit.idStr
     case Value.Ref(l: BuiltinSymbol) =>
       if l.nullary then l.nme
@@ -128,20 +131,20 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       val argsDoc = args.map(argument).mkDocument(", ")
       if c.isMlsFun
       then if checkMLsCalls
-        then doc"${getVar(State.runtimeSymbol)}.checkCall(${base}(${argsDoc}))"
+        then doc"$runtimeVar.checkCall(${base}(${argsDoc}))"
         else doc"${base}(${argsDoc})"
-      else doc"${getVar(State.runtimeSymbol)}.safeCall(${base}(${argsDoc}))"
+      else doc"$runtimeVar.safeCall(${base}(${argsDoc}))"
     case Value.Lam(ps, bod) => scope.nest givenIn:
       val (params, bodyDoc) = setupFunction(none, ps, bod)
       doc"($params) => ${ braced(bodyDoc) }"
     case Select(qual, id) =>
       val name = id.name
       doc"${result(qual)}${
-        if JSBuilder.isValidFieldName(name)
+        if isValidFieldName(name)
         then doc".$name"
         else name.toIntOption match
           case S(index) => s"[$index]"
-          case N => s"[${JSBuilder.makeStringLiteral(name)}]"
+          case N => s"[${makeStringLiteral(name)}]"
       }"
     case DynSelect(qual, fld, ai) =>
       doc"${result(qual)}[${result(fld)}]"
@@ -199,7 +202,9 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
             val name = if sym.nameIsMeaningful then S(sym.nme) else N
             val (params, bodyDoc) = setupFunction(name, ps, result)
             if sym.nameIsMeaningful then
-              doc"${getVar(sym)} = function ${sym.nme}($params) ${ braced(bodyDoc) };"
+              // If the name is not valid JavaScript identifiers, do not use it in the generated function.
+              val nme = if isValidIdentifier(sym.nme) then sym.nme else ""
+              doc"${getVar(sym)} = function $nme($params) ${ braced(bodyDoc) };"
             else
               // in JS, let name = (0, function (args) => {} ) prevents function's name from being bound to `name`
               doc"${getVar(sym)} = (undefined, function ($params) ${ braced(bodyDoc) });"
@@ -262,9 +267,9 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                   .flatMap:
                     case td @ FunDefn(_, _, ps :: pss, bod) => S:
                       doc" # get ${td.sym.nme}$$__checkNotMethod() { ${
-                        getVar(State.runtimeSymbol)
-                      }.deboundMethod(${JSBuilder.makeStringLiteral(td.sym.nme)}, ${
-                        JSBuilder.makeStringLiteral(sym.nme)
+                        runtimeVar
+                      }.deboundMethod(${makeStringLiteral(td.sym.nme)}, ${
+                        makeStringLiteral(sym.nme)
                       }); }"
                     case _ => N
                   .mkDocument(" ")
@@ -286,10 +291,10 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                 else doc""" # ${mtdPrefix}toString() { return "${sym.nme}${
                   if paramsOpt.isEmpty then doc"""""""
                   else doc"""(" + ${
-                      ctorFields.headOption.fold("\"\"")(f => "globalThis.Predef.render(this" + fieldSelect(f._1.name) + ")")
+                      ctorFields.headOption.fold("\"\"")(f => "runtime.render(this" + fieldSelect(f._1.name) + ")")
                     }${
                       ctorFields.tailOption.fold("")(_.map(f =>
-                        """ + ", " + globalThis.Predef.render(this""" + fieldSelect(f._1.name) + ")").mkString)
+                        """ + ", " + runtime.render(this""" + fieldSelect(f._1.name) + ")").mkString)
                     } + ")""""
                 }; }"""
               } #}  # }"
@@ -325,7 +330,8 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                   val funBod = pss.foldRight(bod):
                     case (psDoc, doc_) => doc"($psDoc) => $doc_"
                   val funBodRet = if pss.isEmpty then funBod else braced(doc" # return $funBod")
-                  S(doc"function ${sym.nme}($ps) ${ funBodRet }")
+                  val nme = if isValidIdentifier(sym.nme) then sym.nme else ""
+                  S(doc"function $nme($ps) ${ funBodRet }")
                 case Nil => N
 
               ownr match
@@ -464,17 +470,14 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
 
   def worksheet(p: Program)(using Raise, Scope): (Document, Document) =
     reserveNames(p)
-    p.imports.foreach: i =>
-      i._1 -> scope.allocateName(i._1)
-    val imps = p.imports.map: i =>
-      val v = doc"this.${getVar(i._1)}"
-      doc"""$v = await import("${i._2.toString
-        }"); # if ($v.default !== undefined) $v = $v.default;"""
-    blockPreamble(p.main) -> (imps.mkDocument(doc" # ") :/: returningTerm(p.main, endSemi = false).stripBreaks)
+    lazy val imps = p.imports.map: i =>
+      doc"""${getVar(i._1)} = await import("${i._2.toString}").then(m => m.default ?? m);"""
+    blockPreamble(p.imports.map(_._1).toSeq ++ p.main.definedVars.toSeq) ->
+      (imps.mkDocument(doc" # ") :/: returningTerm(p.main, endSemi = false).stripBreaks)
 
-  def blockPreamble(t: Block)(using Raise, Scope): Document =
+  def blockPreamble(ss: Iterable[Symbol])(using Raise, Scope): Document =
     // TODO document: mutable var assnts require the lookup
-    val vars = t.definedVars.toSeq.filter(scope.lookup(_).isEmpty).sortBy(_.uid).iterator.map(l =>
+    val vars = ss.filter(scope.lookup(_).isEmpty).toArray.sortBy(_.uid).iterator.map(l =>
       l -> scope.allocateName(l))
     if vars.isEmpty then doc"" else
       doc" # let " :: vars.map: (_, nme) =>
@@ -483,7 +486,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
       :: doc";"
 
   def block(t: Block, endSemi: Bool)(using Raise, Scope): Document =
-    blockPreamble(t) :: returningTerm(t, endSemi)
+    blockPreamble(t.definedVars) :: returningTerm(t, endSemi)
 
   def body(t: Block, endSemi: Bool)(using Raise, Scope): Document = scope.nest givenIn:
     block(t, endSemi)
@@ -616,12 +619,12 @@ trait JSBuilderArgNumSanityChecks(using Config, Elaborator.State)
       val paramRest = params.restParam.map(p => Scope.scope.allocateName(p.sym))
       val paramsStr = Scope.scope.allocateName(functionParamVarargSymbol)
       val functionName = JSBuilder.makeStringLiteral(name.fold("")(n => s"${JSBuilder.escapeStringCharacters(n)}"))
-      val checkArgsNum = doc"\nglobalThis.Predef.checkArgs($functionName, ${params.paramCountLB}, ${params.paramCountUB.toString}, $paramsStr.length);"
+      val checkArgsNum = doc"\n$runtimeVar.checkArgs($functionName, ${params.paramCountLB}, ${params.paramCountUB.toString}, $paramsStr.length);"
       val paramsAssign = paramsList.zipWithIndex.map{(nme, i) =>
         doc"\nlet ${nme} = ${paramsStr}[$i];"}.mkDocument("")
       val restAssign = paramRest match
         case N => doc""
-        case S(p) => doc"\nlet $p = runtime.Tuple.slice($paramsStr, ${params.paramCountLB}, 0);"
+        case S(p) => doc"\nlet $p = $runtimeVar.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/Elaborator.scala

@@ -270,7 +270,8 @@ extends Importer:
     case S(cls: ClassSymbol) =>
       trm
     case S(mem: BlockMemberSymbol) =>
-      if !mem.hasLiftedClass then trm
+      // FIXME: `defn` is not available before elaboration. See pull/277#discussion_r2051448677
+      if !mem.hasLiftedClass || mem.defn.exists(_.isDeclare.isDefined) then trm
       else Term.SynthSel(trm, Ident("class"))(mem.clsTree.orElse(mem.modOrObjTree).map(_.symbol))
     case _ => trm
 

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

@@ -485,9 +485,14 @@ class Resolver(tl: TraceLogger)
           case tup: Term.Tup => (
             !tup.fields.exists(_.isInstanceOf[Spd]),
             tup.fields.map:
+              case Fld(asc = S(_)) => 0
               case _: Fld => 1
               case _: Spd => 0
-            .sum,
+            .sum +
+            tup.fields.exists:
+              case Fld(asc = S(_)) => true
+              case _ => false
+            .into(if _ then 1 else 0)
           )
           // Other: spread arguments
           case _ => (false, 0)
@@ -512,33 +517,41 @@ class Resolver(tl: TraceLogger)
            * try to pair as many as possible.
            */
           @tailrec
-          def zip(ps: Ls[Param], as: Ls[Elem], beforeSpread: Bool): Unit = (ps, as) match
+          def zip(ps: Ls[Param], as: Ls[Elem], recordArgs: Ls[Fld], beforeSpread: Bool): Ls[Fld] = (ps, as) match
             // The spread argument takes all the remaining arguments.
             case (ps, (a: Spd) :: as) =>
               traverse(a.term, expect = NonModule(N))
-              zip(ps, as, false)
+              zip(ps, as, recordArgs, false)
             case (ps, a :: as) if !beforeSpread =>
               a.subTerms.foreach(traverse(_, expect = NonModule(N)))
-              zip(ps, as, false)
+              zip(ps, as, recordArgs, false)
 
             // Pair the parameter and the argument.
-            case (p :: ps, (a: Fld) :: as) =>
+            case (p :: ps, (a @ Fld(asc = N)) :: as) =>
               traverse(a.term, 
                 // note: we accept regular arguments for module parameters
                 expect = if p.modulefulness.isModuleful
                   then Any
                   else NonModule(S(msg"Module argument passed to a non-module parameter."))
               )
-              zip(ps, as, true)
+              zip(ps, as, recordArgs, true)
 
-            // If there are more parameters, there must be a spread argument before.
-            case (p :: ps, Nil) => ()
+            // Record Arguments. They are pushed to the last parameter.
+            case (_, (a @ Fld(asc = S(_))) :: as) =>
+              zip(ps, as, a :: recordArgs, true)
+            
+            // If there are more parameters, there must be a spread
+            // argument, or some record arguments before.
+            case (p :: ps, Nil) =>
+              recordArgs.reverse
+              
             // If there are more arguments, all of them go to `restParam`.
             case (Nil, a :: as) =>
               a.subTerms.foreach(traverse(_, expect = NonModule(N)))
-              zip(Nil, as, beforeSpread)
+              zip(Nil, as, recordArgs, beforeSpread)
 
-            case (Nil, Nil) => ()
+            case (Nil, Nil) => 
+              recordArgs.reverse
           end zip
 
           val args = as match
@@ -547,7 +560,9 @@ class Resolver(tl: TraceLogger)
 
           // The lhs of the App is already traversed by the recursive
           // `traverse` or `resolve` at the beginning.
-          zip(ps.params, args, true)
+          val recordArgs = zip(ps.params, args, Nil, true)
+          recordArgs.foreach:
+            _.subTerms.foreach(traverse(_, expect = NonModule(N)))
           S(defn.copy(params = pss))
         case _ =>
           traverse(as, expect = NonModule(N))
@@ -623,7 +638,6 @@ class Resolver(tl: TraceLogger)
             case t: Term.App => sym.map(sym => t.sym = S(sym))
             case t: Term.TyApp => sym.map(sym => t.sym = S(sym))
             case t: Term.Ref => sym.map(sym => t.resSym = S(sym))
-            case _ =>
           log(s"Resolved symbol for ${t}: ${lhsDefn.sym}")
         case _ =>
     case _ => 

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

@@ -2,7 +2,7 @@ package hkmc2
 package semantics
 package ucs
 
-import syntax.{Keyword, Tree}, Tree.*
+import syntax.{Keyword, Tree, BracketKind}, Tree.*
 import mlscript.utils.*, shorthands.*
 import Message.MessageContext
 import utils.TraceLogger
@@ -523,7 +523,7 @@ class Desugarer(val elaborator: Elaborator)
         // Raise an error and discard `sequel`. Use `fallback` instead.
         raise(ErrorReport(msg"Cannot use this ${ctor.describe} as an extractor" -> ctor.toLoc :: Nil))
         fallback
-    pattern.deparenthesized match
+    pattern.deparenthesized.desugared match
       // A single wildcard pattern.
       case Under() => _ => ctx => sequel(ctx)
       // Alias pattern
@@ -610,6 +610,16 @@ class Desugarer(val elaborator: Elaborator)
       case Jux(Ident(".."), Ident(_)) => fallback => _ =>
         raise(ErrorReport(msg"Illegal rest pattern." -> pattern.toLoc :: Nil))
         fallback
+      case InfixApp(id: Ident, Keyword.`:`, pat) => fallback => ctx =>
+        val sym = VarSymbol(id)
+        val ctxWithAlias = ctx + (id.name -> sym)
+        Split.Let(sym, ref.sel(id, N),
+          expandMatch(sym, pat, sequel)(fallback)(ctxWithAlias))
+      case Block(st :: Nil) => fallback => ctx =>
+        expandMatch(scrutSymbol, st, sequel)(fallback)(ctx)
+      // case Block(sts) => fallback => ctx => // TODO
+      case Bra(BracketKind.Curly | BracketKind.Round, inner) => fallback => ctx =>
+        expandMatch(scrutSymbol, inner, sequel)(fallback)(ctx)
       case pattern => fallback => _ =>
         // Raise an error and discard `sequel`. Use `fallback` instead.
         raise(ErrorReport(msg"Unrecognized pattern (${pattern.describe})" -> pattern.toLoc :: Nil))

hkmc2/shared/src/main/scala/hkmc2/syntax/Parser.scala

@@ -281,7 +281,7 @@ abstract class Parser(
     case (IDENT("@", _), l0) :: rest if rest.nonEmpty =>
       consume
       blockOf(rule, simpleExpr(AppPrec) :: annotations, allowNewlines)
-    case (tok @ (id: IDENT), loc) :: _ =>
+    case (tok @ (id: IDENT), loc) :: _ if id.name =/= ":" =>
       Keyword.all.get(id.name) match
       case S(kw) =>
         consume
@@ -501,6 +501,14 @@ abstract class Parser(
   def simpleExpr(prec: Int)(using Line): Tree = wrap(prec)(simpleExprImpl(prec))
   def simpleExprImpl(prec: Int): Tree =
     yeetSpaces match
+    case (IDENT("=", _), l0) :: (IDENT(nme, false), l1) :: rest =>
+      consume
+      consume
+      Pun(true, new Ident(nme).withLoc(S(l1)))
+    case (IDENT(":", _), l0) :: (IDENT(nme, false), l1) :: rest =>
+      consume
+      consume
+      Pun(false, new Ident(nme).withLoc(S(l1)))
     case (IDENT("@", _), l0) :: rest if rest.nonEmpty =>
       consume
       val annotation = simpleExpr(AppPrec)

hkmc2/shared/src/main/scala/hkmc2/syntax/Tree.scala

@@ -45,6 +45,7 @@ enum Tree extends AutoLocated:
   case Under()
   case Unt()
   case Ident(name: Str)
+  case Pun(eql: Bool, id: Ident) // `=ident` (eql) or `:ident` (!eql)
   case Keywrd(kw: Keyword)
   case IntLit(value: BigInt)             extends Tree with Literal
   case DecLit(value: BigDecimal)         extends Tree with Literal
@@ -88,6 +89,7 @@ enum Tree extends AutoLocated:
 
   def children: Ls[Tree] = this match
     case _: Empty | _: Error | _: Ident | _: Literal | _: Under | _: Unt => Nil
+    case Pun(_, e) => e :: Nil
     case Bra(_, e) => e :: Nil
     case Block(stmts) => stmts
     case OpBlock(items) => items.flatMap:
@@ -155,7 +157,7 @@ enum Tree extends AutoLocated:
     case SynthSel(prefix, name) => "synthetic selection"
     case DynAccess(prefix, name, true) => "dynamic index access"
     case DynAccess(prefix, name, false) => "dynamic field access"
-    case InfixApp(lhs, kw, rhs) => "infix operation"
+    case InfixApp(lhs, kw, rhs) => "infix operator"
     case New(body, _) => "new"
     case IfLike(Keyword.`if`, _, split) => "if expression"
     case IfLike(Keyword.`while`, _, split) => "while expression"
@@ -171,6 +173,7 @@ enum Tree extends AutoLocated:
     case Open(_) => "open"
     case MemberProj(_, _) => "member projection"
     case Keywrd(kw) => s"'${kw.name}' keyword"
+    case Unt() => "unit"
     case Dummy => "‹dummy›"
 
   def deparenthesized: Tree = this match
@@ -181,6 +184,9 @@ enum Tree extends AutoLocated:
 
   lazy val desugared: Tree = this match
 
+    case Pun(false, id) =>
+      InfixApp(id, Keyword.`:`, id)
+    
     // TODO generalize to pattern-let and rm this special case
     case LetLike(kw, und @ Under(), r, b) =>
       LetLike(kw, Ident("_").withLocOf(und), r, b)

hkmc2/shared/src/test/mlscript-compile/.gitignore

@@ -0,0 +1,5 @@
+*.mjs
+!/Predef.mjs
+!/Runtime.mjs
+!/RuntimeJS.mjs
+!/apps/parsing/vendors/railroad/railroad.mjs

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

@@ -0,0 +1,9 @@
+module Char with
+  pattern Lowercase = "a" ..= "z"
+  pattern Uppercase = "A" ..= "Z"
+  pattern Letter = Lowercase | Uppercase
+  pattern Digit = "0" ..= "9"
+  pattern HexDigit = Digit | "a" ..= "f" | "A" ..= "F"
+  pattern OctDigit = "0" ..= "7"
+  pattern BinDigit = "0" | "1"
+  pattern Whitespace = " " | "\t" | "\n" | "\r"