Remove Predef declaration from Prelude

It had nothing to do there in the first place.

Author: LPTK

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

@@ -103,7 +103,6 @@ object Elaborator:
       val Object = assumeBuiltinCls("Object")
       val untyped = assumeBuiltinTpe("untyped")
       // println(s"Builtins: $Int, $Num, $Str, $untyped")
-      val Predef = assumeBuiltinMod("Predef")
       object source:
         private val module = assumeBuiltinMod("source")
         private def assumeObject(nme: Str): BlockMemberSymbol =
@@ -152,8 +151,14 @@ object Elaborator:
     given State = this
     val globalThisSymbol = TopLevelSymbol("globalThis")
     val runtimeSymbol = TempSymbol(N, "runtime")
-    val effectSigSymbol = ClassSymbol(Tree.TypeDef(syntax.Cls, Tree.Error(), N, N), Tree.Ident("EffectSig"))
-    val returnClsSymbol = ClassSymbol(Tree.TypeDef(syntax.Cls, Tree.Error(), N, N), Tree.Ident("Return"))
+    val effectSigSymbol = ClassSymbol(TypeDef(syntax.Cls, Dummy, N, N), Ident("EffectSig"))
+    val returnClsSymbol = ClassSymbol(TypeDef(syntax.Cls, Dummy, N, N), Ident("Return"))
+    val matchResultClsSymbol =
+      val id = new Ident("MatchResult")
+      ClassSymbol(TypeDef(syntax.Cls, App(id, Tup(Ident("captures") :: Nil)), N, N), id)
+    val matchFailureClsSymbol =
+      val id = new Ident("MatchFailure")
+      ClassSymbol(TypeDef(syntax.Cls, App(id, Tup(Ident("errors") :: Nil)), N, N), id)
     val builtinOpsMap =
       val baseBuiltins = builtins.map: op =>
           op -> BuiltinSymbol(op,

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

@@ -74,9 +74,9 @@ enum Term extends Statement:
     case sel: SelProj => sel.sym
     case _ => N
 
-  def sel(id: Tree.Ident, sym: Opt[FieldSymbol]) =
+  def sel(id: Tree.Ident, sym: Opt[FieldSymbol]): Sel =
     Sel(this, id)(sym)
-  def selNoSym(nme: Str, synth: Bool = false) =
+  def selNoSym(nme: Str, synth: Bool = false): Sel | SynthSel =
     val id = new Tree.Ident(nme)
     if synth
     then SynthSel(this, id)(N)

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

@@ -3,10 +3,10 @@ package semantics
 package ucs
 
 import mlscript.utils.*, shorthands.*
-import syntax.Tree.*, Elaborator.{Ctxl, ctx}
+import syntax.Tree.*, Elaborator.{Ctxl, ctx}, Elaborator.State
 
 /** Contains some helpers that makes UCS desugaring easier. */
-trait DesugaringBase(using state: Elaborator.State):
+trait DesugaringBase(using state: State):
   val elaborator: Elaborator
 
   import elaborator.tl.*, state.globalThisSymbol
@@ -22,30 +22,24 @@ trait DesugaringBase(using state: Elaborator.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)
 
-  /** Get the class symbol defined in the `Predef` module. */
-  protected def resolvePredefMember(name: Str): Ctxl[(Term.SynthSel, ClassSymbol)] =
-    val predefSymbol = ctx.builtins.Predef
-    val innerSel = sel(globalThisSymbol.ref(), "Predef", predefSymbol)
-    val memberSymbol = predefSymbol.tree.definedSymbols.get(name).flatMap(_.asCls).getOrElse:
-      lastWords(s"Cannot resolve `$name` in `Predef`.")
-    (sel(innerSel, name, memberSymbol), memberSymbol)
-
   /** Make a term looks like `globalThis.Predef.MatchResult` with its symbol. */
-  protected lazy val matchResultClass: Ctxl[(Term.SynthSel, ClassSymbol)] = resolvePredefMember("MatchResult")
+  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`. */
   protected def matchResultPattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
-    val classSel = Term.SynthSel(matchResultClass._1, Ident("class"))(S(classSym))
+    val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
     Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
 
   /** Make a term looks like `globalThis.Predef.MatchFailure` with its symbol. */
-  protected lazy val matchFailureClass: Ctxl[(Term.SynthSel, ClassSymbol)] = resolvePredefMember("MatchFailure")
+  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`. */
   protected def matchFailurePattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
-    val classSel = Term.SynthSel(matchResultClass._1, Ident("class"))(S(classSym))
+    val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
     Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
 
   /** Create a term that selects a method in the `Predef` module. */

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

@@ -124,6 +124,7 @@ enum Tree extends AutoLocated:
     case Annotated(annotation, target) => annotation :: target :: Nil
     case MemberProj(cls, name) => cls :: Nil
     case Keywrd(kw) => Nil
+    case Dummy => Nil
 
   def describe: Str = this match
     case Empty() => "empty"
@@ -169,7 +170,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
     case Bra(BracketKind.Round, inner) => inner.deparenthesized

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

@@ -5,24 +5,6 @@ Predef1 = class Predef {
   static {
     this.assert = globalThis.console.assert;
     this.foldl = Predef.fold;
-    this.MatchResult = function MatchResult(captures1) {
-      return new MatchResult.class(captures1);
-    };
-    this.MatchResult.class = class MatchResult {
-      constructor(captures) {
-        this.captures = captures;
-      }
-      toString() { return "MatchResult(" + globalThis.Predef.render(this.captures) + ")"; }
-    };
-    this.MatchFailure = function MatchFailure(errors1) {
-      return new MatchFailure.class(errors1);
-    };
-    this.MatchFailure.class = class MatchFailure {
-      constructor(errors) {
-        this.errors = errors;
-      }
-      toString() { return "MatchFailure(" + globalThis.Predef.render(this.errors) + ")"; }
-    };
     this.TraceLogger = class TraceLogger {
       static {
         this.enabled = false;

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

@@ -133,9 +133,6 @@ fun stringGet(string, i) = string.at(i)
 fun stringDrop(string, n) = string.slice(n)
 
 
-class MatchResult(captures)
-class MatchFailure(errors)
-
 fun unreachable = throw Error("unreachable")
 
 fun checkArgs(functionName, expected, isUB, got) =

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

@@ -10,6 +10,24 @@ Runtime1 = class Runtime {
     };
     this.Unit = new Unit$class;
     this.Unit.class = Unit$class;
+    this.MatchResult = function MatchResult(captures1) {
+      return new MatchResult.class(captures1);
+    };
+    this.MatchResult.class = class MatchResult {
+      constructor(captures) {
+        this.captures = captures;
+      }
+      toString() { return "MatchResult(" + globalThis.Predef.render(this.captures) + ")"; }
+    };
+    this.MatchFailure = function MatchFailure(errors1) {
+      return new MatchFailure.class(errors1);
+    };
+    this.MatchFailure.class = class MatchFailure {
+      constructor(errors) {
+        this.errors = errors;
+      }
+      toString() { return "MatchFailure(" + globalThis.Predef.render(this.errors) + ")"; }
+    };
     this.FunctionContFrame = function FunctionContFrame(next1) {
       return new FunctionContFrame.class(next1);
     };

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

@@ -20,6 +20,11 @@ fun deboundMethod(mtdName, clsName) =
     "[debinding error] Method '" + mtdName + "' of class '" + clsName + "' was accessed without being called."
 
 
+// For `pattern` definitions
+class MatchResult(captures)
+class MatchFailure(errors)
+
+
 // Private definitions for algebraic effects
 
 abstract class FunctionContFrame(next) with

hkmc2/shared/src/test/mlscript/decls/Prelude.mls

@@ -42,15 +42,11 @@ declare val Infinity
 declare fun parseInt(str: Str, radix: Int): Int
 declare fun parseFloat(str: Str): Num
 
-declare module Predef with
-  class Test with
-    val x = 0
-  class MatchResult(captures)
-  class MatchFailure(errors)
-
 
 declare module source with
   object
     line
     name
     file
+
+

hkmc2/shared/src/test/mlscript/rp/MatchResult.mls

@@ -1,5 +1,10 @@
 :js
 
+import "../../mlscript-compile/Runtime.mls"
+
+open Runtime { MatchResult, MatchFailure }
+
+
 MatchResult(0)
 //│ = MatchResult(0)
 
@@ -32,7 +37,7 @@ fun foo(x) = x is Cross
 //│ foo = function foo(x2) {
 //│   let matchResult;
 //│   matchResult = runtime.safeCall(Cross1.unapply(x2));
-//│   if (matchResult instanceof globalThis.Predef.MatchResult.class) {
+//│   if (matchResult instanceof runtime.MatchResult.class) {
 //│     return true
 //│   } else {
 //│     return false