Improve handling of builtin ops + add Predef functions & various tests

Author: LPTK

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

@@ -1,6 +1,8 @@
 package hkmc2
 package codegen
 
+import scala.language.implicitConversions
+
 import mlscript.utils.*, shorthands.*
 import utils.*
 
@@ -76,6 +78,38 @@ class Lowering(using TL, Raise, Elaborator.State):
       }(Nil)
     case st.Ref(sym) =>
       sym match
+      case sym: BuiltinSymbol =>
+        warnStmt
+        if sym.binary then
+          val t1 = new Tree.Ident("arg1")
+          val t2 = new Tree.Ident("arg2")
+          val p1 = Param(FldFlags.empty, VarSymbol(t1), N)
+          val p2 = Param(FldFlags.empty, VarSymbol(t2), N)
+          val ps = PlainParamList(p1 :: p2 :: Nil)
+          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666), st.Ref(p2.sym)(t2, 666)))
+            (Tree.Tup(Nil // FIXME should not be required (using dummy value)
+              )))(
+              Tree.App(Tree.Empty(), Tree.Empty()), // FIXME should not be required (using dummy value)
+              FlowSymbol(sym.nme)
+            )
+          val (paramLists, bodyBlock) = setupFunctionDef(ps :: Nil, bod, S(sym.nme))
+          tl.log(s"Ref builtin $sym")
+          assert(paramLists.length === 1)
+          return k(Value.Lam(paramLists.head, bodyBlock))
+        if sym.unary then
+          val t1 = new Tree.Ident("arg")
+          val p1 = Param(FldFlags.empty, VarSymbol(t1), N)
+          val ps = PlainParamList(p1 :: Nil)
+          val bod = st.App(t, st.Tup(List(st.Ref(p1.sym)(t1, 666)))
+            (Tree.Tup(Nil // FIXME should not be required (using dummy value)
+              )))(
+              Tree.App(Tree.Empty(), Tree.Empty()), // FIXME should not be required (using dummy value)
+              FlowSymbol(sym.nme)
+            )
+          val (paramLists, bodyBlock) = setupFunctionDef(ps :: Nil, bod, S(sym.nme))
+          tl.log(s"Ref builtin $sym")
+          assert(paramLists.length === 1)
+          return k(Value.Lam(paramLists.head, bodyBlock))
       case bs: BlockMemberSymbol =>
         bs.defn match
         case S(td: TermDefinition) if td.k is syntax.Fun =>
@@ -90,6 +124,35 @@ class Lowering(using TL, Raise, Elaborator.State):
       case _ => ()
       warnStmt
       k(subst(Value.Ref(sym)))
+    case st.App(Ref(sym: BuiltinSymbol), arg) =>
+      arg match
+      case st.Tup(Nil) =>
+        if !sym.nullary then raise:
+          ErrorReport(
+            msg"Expected arguments for ${sym.nme}" -> t.toLoc :: Nil, S(arg),
+            source = Diagnostic.Source.Compilation)
+        k(Value.Ref(sym))
+      case st.Tup(Fld(FldFlags.benign(), arg, N) :: Nil) =>
+        if !sym.unary then raise:
+          ErrorReport(
+            msg"Expected a single argument for ${sym.nme}" -> t.toLoc :: Nil, S(arg),
+            source = Diagnostic.Source.Compilation)
+        subTerm(arg): ar =>
+          k(Call(Value.Ref(sym), Arg(false, ar) :: Nil)(true))
+      case st.Tup(Fld(FldFlags.benign(), arg1, N) :: Fld(FldFlags.benign(), arg2, N) :: Nil) =>
+        if !sym.binary then raise:
+          ErrorReport(
+            msg"Expected two arguments for ${sym.nme}" -> t.toLoc :: Nil, S(arg),
+            source = Diagnostic.Source.Compilation)
+        subTerm(arg1): ar1 =>
+          subTerm(arg2): ar2 =>
+            k(Call(Value.Ref(sym), Arg(false, ar1) :: Arg(false, ar2) :: Nil)(true))
+      case _ =>
+        raise:
+          ErrorReport(
+            msg"Unexpected arguments for builtin symbol '${sym.nme}'" -> arg.toLoc :: Nil, S(arg),
+            source = Diagnostic.Source.Compilation)
+        End("error")
     case st.App(f, arg) =>
       val isMlsFun = f.symbol.fold(f.isInstanceOf[st.Lam]):
         case _: sem.BuiltinSymbol => true

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

@@ -117,7 +117,11 @@ object Elaborator:
     val globalThisSymbol = TopLevelSymbol("globalThis")
     val builtinOpsMap =
       val baseBuiltins = builtins.map: op =>
-          op -> BuiltinSymbol(op, binary = binaryOps(op), unary = unaryOps(op), nullary = false, functionLike = anyOps(op))
+          op -> BuiltinSymbol(op,
+            binary = binaryOps(op),
+            unary = unaryOps(op),
+            nullary = false,
+            functionLike = anyOps(op))
         .toMap
       baseBuiltins ++ aliasOps.map:
         case (alias, base) => alias -> baseBuiltins(base)

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

@@ -365,6 +365,8 @@ sealed abstract class Elem:
     case Fld(_, term, asc) => term :: asc.toList
     case Spd(_, term) => term :: Nil
   def showDbg: Str
+object Elem:
+  given Conversion[Term, Elem] = PlainFld(_)
 final case class Fld(flags: FldFlags, term: Term, asc: Opt[Term]) extends Elem with FldImpl
 object PlainFld:
   def apply(term: Term) = Fld(FldFlags.empty, term, N)

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

@@ -1,6 +1,7 @@
 const Predef$class = class Predef {
   constructor() {
     this.assert = console.assert;
+    this.foldl = this.fold;
     this.MatchResult = function MatchResult(captures1) { return new MatchResult.class(captures1); };
     this.MatchResult.class = class MatchResult {
       constructor(captures) {
@@ -138,13 +139,70 @@ const Predef$class = class Predef {
   get notImplementedError() {
     throw Error("Not implemented");
   } 
-  tupleSlice(xs1, i, j) {
+  tuple(...xs1) {
+    return xs1;
+  } 
+  tupleSlice(xs2, i, j) {
     let tmp;
-    tmp = xs1.length - j;
-    return globalThis.Array.prototype.slice.call(xs1, i, tmp) ?? null;
+    tmp = xs2.length - j;
+    return globalThis.Array.prototype.slice.call(xs2, i, tmp) ?? null;
+  } 
+  tupleGet(xs3, i1) {
+    return globalThis.Array.prototype.at.call(xs3, i1);
+  } 
+  fold(f9) {
+    return (init, ...rest) => {
+      let i2, len, scrut, tmp, tmp1, tmp2, tmp3;
+      i2 = 0;
+      len = rest.length;
+      tmp4: while (true) {
+        scrut = i2 < len;
+        if (scrut) {
+          tmp = rest.at(i2) ?? null;
+          tmp1 = f9(init, tmp) ?? null;
+          init = tmp1;
+          tmp2 = i2 + 1;
+          i2 = tmp2;
+          tmp3 = null;
+          continue tmp4;
+        } else {
+          tmp3 = null;
+        }
+        break;
+      }
+      return init;
+    };
   } 
-  tupleGet(xs2, i1) {
-    return globalThis.Array.prototype.at.call(xs2, i1);
+  foldr(f10) {
+    return (first, ...rest) => {
+      let len, i2, init, scrut, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5;
+      len = rest.length;
+      scrut1 = len == 0;
+      if (scrut1) {
+        return first;
+      } else {
+        tmp = len - 1;
+        i2 = tmp;
+        tmp1 = rest.at(i2) ?? null;
+        init = tmp1;
+        tmp6: while (true) {
+          scrut = i2 > 0;
+          if (scrut) {
+            tmp2 = i2 - 1;
+            i2 = tmp2;
+            tmp3 = rest.at(i2) ?? null;
+            tmp4 = f10(tmp3, init) ?? null;
+            init = tmp4;
+            tmp5 = null;
+            continue tmp6;
+          } else {
+            tmp5 = null;
+          }
+          break;
+        }
+        return f10(first, init) ?? null;
+      }
+    };
   } 
   stringStartsWith(string, prefix) {
     return string.startsWith(prefix) ?? null;
@@ -156,7 +214,7 @@ const Predef$class = class Predef {
     return string2.slice(n) ?? null;
   } 
   checkArgs(functionName, expected, isUB, got) {
-    let scrut, name, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11;
+    let scrut, name, scrut1, scrut2, tmp, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
     tmp = got < expected;
     tmp1 = got > expected;
     tmp2 = isUB && tmp1;
@@ -170,18 +228,22 @@ const Predef$class = class Predef {
         tmp4 = "";
       }
       name = tmp4;
-      tmp5 = "Function" + name;
-      tmp6 = tmp5 + " expected ";
+      tmp5 = this.fold((arg1, arg2) => {
+        return arg1 + arg2;
+      });
       if (isUB) {
+        tmp6 = "";
+      } else {
+        tmp6 = "at least ";
+      }
+      scrut2 = expected === 1;
+      if (scrut2) {
         tmp7 = "";
       } else {
-        tmp7 = "at least ";
+        tmp7 = "s";
       }
-      tmp8 = tmp6 + tmp7;
-      tmp9 = tmp8 + expected;
-      tmp10 = " argument(s) but got " + got;
-      tmp11 = tmp9 + tmp10;
-      throw globalThis.Error(tmp11) ?? null;
+      tmp8 = tmp5("Function", name, " expected ", tmp6, expected, " argument", tmp7, " but got ", got) ?? null;
+      throw Error(tmp8);
     } else {
       return null;
     }

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

@@ -5,6 +5,7 @@ fun id(x) = x
 
 fun not(x) = x is false
 
+
 fun (|>) pipeInto(x, f) = f(x)
 fun (<|) pipeFrom(f, x) = f(x)
 
@@ -19,6 +20,7 @@ fun pass1(f)(...xs) = f(xs.0)
 fun pass2(f)(...xs) = f(xs.0, xs.1)
 fun pass3(f)(...xs) = f(xs.0, xs.1, xs.2)
 
+
 fun print(...xs) =
   console.log(...xs.map(String))
 
@@ -27,28 +29,66 @@ val assert = console.assert
 fun (??) notImplemented(msg) = throw Error("Not implemented: " + msg)
 fun (???) notImplementedError = throw Error("Not implemented")
 
+
+fun tuple(...xs) = xs
+
 fun tupleSlice(xs, i, j) =
   globalThis.Array.prototype.slice.call(xs, i, xs.length - j)
 
 fun tupleGet(xs, i) =
   globalThis.Array.prototype.at.call(xs, i)
 
+fun fold(f)(init, ...rest) =
+  let
+    i = 0
+    len = rest.length
+  while i < len do
+    set
+      init = f(init, rest.at(i))
+      i += 1
+  init
+
+val foldl = fold
+
+// fun foldr(f)(...rest, init) = // TODO allow this syntax
+fun foldr(f)(first, ...rest) =
+  let len = rest.length
+  if len == 0 then first else...
+  let
+    i = len - 1
+    init = rest.at(i)
+  while i > 0 do
+    set
+      i -= 1
+      init = f(rest.at(i), init)
+  f(first, init)
+
+
 fun stringStartsWith(string, prefix) = string.startsWith(prefix)
 
 fun stringGet(string, i) = string.at(i)
 
 fun stringDrop(string, n) = string.slice(n)
 
+
 class MatchResult(captures)
 class MatchFailure(errors)
 
+
 fun checkArgs(functionName, expected, isUB, got) =
   if got < expected || isUB && got > expected do
     let name = if functionName.length > 0 then " '" + functionName + "'" else ""
-    throw globalThis.Error("Function" + name + " expected "
-      + (if isUB then "" else "at least ")
-      + expected
-      + " argument(s) but got " + got)
+    // throw globalThis.Error("Function" + name + " expected "
+    //   + (if isUB then "" else "at least ")
+    //   + expected
+    //   + " argument(s) but got " + got)
+    throw Error of fold(+) of
+      "Function", name, " expected "
+      if isUB then "" else "at least "
+      expected, " argument"
+      if expected === 1 then "" else "s"
+      " but got ", got
+
 
 module TraceLogger with
   mut val enabled = false
@@ -68,7 +108,9 @@ module TraceLogger with
       console.log("| ".repeat(indentLvl) + msg.replaceAll("\n", "\n" + "  ".repeat(indentLvl)))
     else ()
 
+
 class Test with
   print("Test")
   val y = 1
 
+

hkmc2/shared/src/test/mlscript/backlog/Records.mls

@@ -0,0 +1,43 @@
+:js
+
+
+// * Should we use this syntax?
+
+:todo
+let rcd =
+  fieldA: 1
+  fieldB:
+    "..."
+//│ ╔══[ERROR] Name not found: fieldA
+//│ ║  l.8: 	  fieldA: 1
+//│ ╙──     	  ^^^^^^
+//│ ╔══[ERROR] Name not found: fieldB
+//│ ║  l.9: 	  fieldB:
+//│ ╙──     	  ^^^^^^
+
+// * Or this syntax?
+
+:todo
+let rcd =
+  fieldA = 1
+  fieldB =
+    "..."
+//│ ╔══[ERROR] Name not found: fieldA
+//│ ║  l.22: 	  fieldA = 1
+//│ ╙──      	  ^^^^^^
+//│ ╔══[ERROR] Name not found: fieldB
+//│ ║  l.23: 	  fieldB =
+//│ ╙──      	  ^^^^^^
+
+// * Or this syntax?
+
+:todo
+let rcd = new with
+  fieldA = 1
+  fieldB =
+    "..."
+//│ ╔══[PARSE ERROR] Expected expression or block after `new` keyword; found 'with' keyword instead
+//│ ║  l.35: 	let rcd = new with
+//│ ╙──      	              ^^^^
+
+

hkmc2/shared/src/test/mlscript/backlog/UCS.mls

@@ -95,3 +95,18 @@ else
 
 // ——— ——— ———
 
+// * Example confusing parses that should be fixed when we fix the parsing of operator splits
+
+if 1 + 0
+    == 0 then "X"
+    == 1 then "A"
+//│ = 'A'
+
+if 1 + 1
+    * 2 == 4 then "X"
+    * 2 == 1 then "A"
+    |> id is r then r
+//│ = 2
+
+// ——— ——— ———
+

hkmc2/shared/src/test/mlscript/basics/BadMemberProjections.mls

@@ -29,7 +29,7 @@
 //│   let args = globalThis.Predef.tupleSlice(args1, 1, 0);
 //│   return self.x(...args) ?? null;
 //│ })()
-//│ ═══[RUNTIME ERROR] Error: Function expected at least 1 argument(s) but got 0
+//│ ═══[RUNTIME ERROR] Error: Function expected at least 1 argument but got 0
 
 
 fun (::) f(a, b) = [a, b]