Generate argument number checks for JS code (#237)

Author: CrescentonC

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

@@ -5,6 +5,12 @@ import scala.collection.mutable
 import mlscript.utils.*, shorthands.*
 import utils.*
 
+import codegen.js.{JSBuilder, JSBuilderSanityChecks}
+import document.*
+import codegen.Block
+import codegen.js.Scope
+import hkmc2.syntax.Tree.Ident
+import hkmc2.codegen.Path
 
 abstract class JSBackendDiffMaker extends MLsDiffMaker:
 
@@ -13,6 +19,7 @@ abstract class JSBackendDiffMaker extends MLsDiffMaker:
   val sjs = NullaryCommand("sjs")
   val showRepl = NullaryCommand("showRepl")
   val silent = NullaryCommand("silent")
+  val noSanityCheck = NullaryCommand("noSanityCheck")
   val expect = Command("expect"): ln =>
     ln.trim
 
@@ -42,7 +49,7 @@ abstract class JSBackendDiffMaker extends MLsDiffMaker:
     if js.isSet then
       val low = ltl.givenIn:
         codegen.Lowering()
-      val jsb = codegen.js.JSBuilder()
+      val jsb = new JSBuilder with JSBuilderSanityChecks(noSanityCheck.isUnset)
       import semantics.*
       import codegen.*
       val le = low.program(blk)

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

@@ -96,9 +96,9 @@ class JSBuilder extends CodeBuilder:
         case _ => result(fun)
       doc"${base}(${args.map(result).mkDocument(", ")})"
     case Value.Lam(ps, bod) => scope.nest givenIn:
-      val vars = ps.map(p => scope.allocateName(p.sym)).mkDocument(", ")
-      doc"($vars) => { #{  # ${
-        body(bod)
+      val (params, bodyDoc) = setupFunction(none, ps, bod)
+      doc"($params) => { #{  # ${
+        bodyDoc
       } #}  # }"
     case Select(qual, id) =>
       val name = id.name
@@ -145,11 +145,11 @@ class JSBuilder extends CodeBuilder:
           case FunDefn(sym, Nil, body) =>
             TODO("getters")
           case FunDefn(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)} #}  # }"
+            val (params, bodyDoc) = setupFunction(some(sym.nme), ps, result)
+            doc"function ${sym.nme}($params) { #{  # ${bodyDoc} #}  # }"
           case ClsLikeDefn(sym, syntax.Cls, mtds, flds, ctor) =>
             val clsDefn = sym.defn.getOrElse(die)
             val clsParams = clsDefn.paramsOpt.getOrElse(Nil)
@@ -166,12 +166,12 @@ class JSBuilder extends CodeBuilder:
               } #}  # }${
                 mtds.map: 
                   case td @ FunDefn(_, ParamList(_, ps) :: pss, bod) =>
-                    val vars = ps.map(p => scope.allocateName(p.sym)).mkDocument(", ")
                     val result = pss.foldRight(bod):
                       case (ParamList(_, ps), block) => 
                         Return(Lam(ps, block), false)
-                    doc" # ${td.sym.nme}($vars) { #{  # ${
-                      body(result)
+                    val (params, bodyDoc) = setupFunction(some(td.sym.nme), ps, result)
+                    doc" # ${td.sym.nme}($params) { #{  # ${
+                      bodyDoc
                     } #}  # }"
                 .mkDocument(" ")
               }${
@@ -329,7 +329,12 @@ class JSBuilder extends CodeBuilder:
   def body(t: Block)(using Raise, Scope): Document = scope.nest givenIn:
     block(t)
 
-  
+  def setupFunction(name: Option[Str], params: List[semantics.Param], body: Block)(using Raise, Scope): (Document, Document) =
+    val paramsList = params.map(p => scope.allocateName(p.sym)).mkDocument(", ")
+    (paramsList, this.body(body))
+
+
+
 object JSBuilder:
   import scala.util.matching.Regex
 
@@ -400,6 +405,9 @@ object JSBuilder:
   )
 
   def makeStringLiteral(s: Str): Str =
+    s"\"${escapeStringCharacters(s)}\""
+  
+  def escapeStringCharacters(s: Str): Str =
     s.map[Str] {
       case '"'  => "\\\""
       case '\\' => "\\\\"
@@ -412,8 +420,24 @@ object JSBuilder:
         if 0 < c && c <= 255 && !c.isControl
         then c.toString
         else f"\\u${c.toInt}%04X"
-    }.mkString("\"", "", "\"")
+    }.mkString
 
 end JSBuilder
 
 
+trait JSBuilderSanityChecks(instrument: Bool) extends JSBuilder:
+  
+  val functionParamVarargSymbol = semantics.TempSymbol(0, N, "args")
+  
+  override def setupFunction(name: Option[Str], params: List[semantics.Param], body: Block)(using Raise, Scope): (Document, Document) =
+    if instrument then
+      val paramsList = params.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"globalThis.Predef.checkArgs($functionName, ${params.length}, $paramsStr.length);\n"
+      val paramsAssign = paramsList.zipWithIndex.map{(nme, i) =>
+        doc"let ${nme} = ${paramsStr}[$i];\n"}.mkDocument("")
+      (doc"...$paramsStr", doc"$checkArgsNum$paramsAssign${this.body(body)}")
+    else
+      super.setupFunction(name, params, body)
+

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

@@ -32,6 +32,28 @@ const Predef$class = class Predef {
   } 
   tupleGet(xs1, i1) {
     return globalThis.Array.prototype.at.call(xs1, i1);
+  } 
+  checkArgs(functionName, expected, got) {
+    let scrut, name, scrut1, tmp, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
+    scrut = got != expected;
+    if (scrut) {
+      scrut1 = functionName.length > 0;
+      if (scrut1) {
+        tmp = " '" + functionName;
+        tmp1 = tmp + "'";
+      } else {
+        tmp1 = "";
+      }
+      name = tmp1;
+      tmp2 = "Function" + name;
+      tmp3 = tmp2 + " expected ";
+      tmp4 = tmp3 + expected;
+      tmp5 = tmp4 + " arguments but got ";
+      tmp6 = tmp5 + got;
+      throw globalThis.Error(tmp6);
+    } else {
+      return undefined;
+    }
   }
   toString() { return "Predef"; }
 }; const Predef = new Predef$class;

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

@@ -20,3 +20,9 @@ fun tupleSlice(xs, i, j) =
 
 fun tupleGet(xs, i) =
   globalThis.Array.prototype.at.call(xs, i)
+
+fun checkArgs(functionName, expected, got) =
+  if got != expected then
+    let name = if functionName.length > 0 then " '" + functionName + "'" else ""
+    throw globalThis.Error("Function" + name + " expected " + expected + " arguments but got " + got)
+  else ()

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

@@ -6,7 +6,12 @@
 
 fun f(n1: Int): Int = n1
 //│ JS:
-//│ function f(n1) { return n1; } undefined
+//│ function f(...args) {
+//│   globalThis.Predef.checkArgs("f", 1, args.length);
+//│   let n1 = args[0];
+//│   return n1;
+//│ }
+//│ undefined
 
 f(42)
 //│ JS:
@@ -15,7 +20,18 @@ f(42)
 
 fun f(n1: Int)(n2: Int): Int =  (10 * n1 + n2)
 //│ JS:
-//│ function f(n1) { return (n2) => { let tmp; tmp = 10 * n1; return tmp + n2; }; } undefined
+//│ function f(...args) {
+//│   globalThis.Predef.checkArgs("f", 1, args.length);
+//│   let n1 = args[0];
+//│   return (...args1) => {
+//│     globalThis.Predef.checkArgs("", 1, args1.length);
+//│     let n2 = args1[0];
+//│     let tmp;
+//│     tmp = 10 * n1;
+//│     return tmp + n2;
+//│   };
+//│ }
+//│ undefined
 
 f(4)(2)
 //│ JS:
@@ -24,9 +40,15 @@ f(4)(2)
 
 fun f(n1: Int)(n2: Int)(n3: Int): Int = 10 * (10 * n1 + n2) + n3
 //│ JS:
-//│ function f(n1) {
-//│   return (n2) => {
-//│     return (n3) => {
+//│ function f(...args) {
+//│   globalThis.Predef.checkArgs("f", 1, args.length);
+//│   let n1 = args[0];
+//│   return (...args1) => {
+//│     globalThis.Predef.checkArgs("", 1, args1.length);
+//│     let n2 = args1[0];
+//│     return (...args2) => {
+//│       globalThis.Predef.checkArgs("", 1, args2.length);
+//│       let n3 = args2[0];
 //│       let tmp, tmp1, tmp2;
 //│       tmp = 10 * n1;
 //│       tmp1 = tmp + n2;
@@ -44,10 +66,18 @@ f(4)(2)(0)
 
 fun f(n1: Int)(n2: Int)(n3: Int)(n4: Int): Int = 10 * (10 * (10 * n1 + n2) + n3) + n4
 //│ JS:
-//│ function f(n1) {
-//│   return (n2) => {
-//│     return (n3) => {
-//│       return (n4) => {
+//│ function f(...args) {
+//│   globalThis.Predef.checkArgs("f", 1, args.length);
+//│   let n1 = args[0];
+//│   return (...args1) => {
+//│     globalThis.Predef.checkArgs("", 1, args1.length);
+//│     let n2 = args1[0];
+//│     return (...args2) => {
+//│       globalThis.Predef.checkArgs("", 1, args2.length);
+//│       let n3 = args2[0];
+//│       return (...args3) => {
+//│         globalThis.Predef.checkArgs("", 1, args3.length);
+//│         let n4 = args3[0];
 //│         let tmp, tmp1, tmp2, tmp3, tmp4;
 //│         tmp = 10 * n1;
 //│         tmp1 = tmp + n2;

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

@@ -13,6 +13,6 @@ foo of (id of x => 1), id of y => 2
 
 :re
 foo(id of x => 1, id of y => 2) 
-//│ ═══[RUNTIME ERROR] TypeError: g is not a function
+//│ ═══[RUNTIME ERROR] Error: Function 'id' expected 1 arguments but got 2
 
 

hkmc2/shared/src/test/mlscript/codegen/CaseOfCase.mls

@@ -18,7 +18,9 @@ fun test(x) =
     Some(v) then log(v)
     None then log("none")
 //│ JS:
-//│ function test(x) {
+//│ function test(...args) {
+//│   globalThis.Predef.checkArgs("test", 1, args.length);
+//│   let x = args[0];
 //│   let param0, v, scrut, param01, v1, tmp, tmp1;
 //│   if (x instanceof globalThis.Some.class) {
 //│     param0 = x.value;

hkmc2/shared/src/test/mlscript/codegen/CaseShorthand.mls

@@ -11,21 +11,37 @@ case x then x
 :sjs
 case { x then x }
 //│ JS:
-//│ (caseScrut) => { let x; x = caseScrut; return x; }
+//│ (...args) => {
+//│   globalThis.Predef.checkArgs("", 1, args.length);
+//│   let caseScrut = args[0];
+//│   let x;
+//│   x = caseScrut;
+//│   return x;
+//│ }
 //│ = [Function (anonymous)]
 
 :sjs
 x => if x is
   0 then true
 //│ JS:
-//│ (x) => { if (x === 0) { return true; } else { throw new this.Error("match error"); } }
+//│ (...args) => {
+//│   globalThis.Predef.checkArgs("", 1, args.length);
+//│   let x = args[0];
+//│   if (x === 0) {
+//│     return true;
+//│   } else {
+//│     throw new this.Error("match error");
+//│   }
+//│ }
 //│ = [Function (anonymous)]
 
 :sjs
 case
   0 then true
 //│ JS:
-//│ (caseScrut) => {
+//│ (...args) => {
+//│   globalThis.Predef.checkArgs("", 1, args.length);
+//│   let caseScrut = args[0];
 //│   if (caseScrut === 0) {
 //│     return true;
 //│   } else {
@@ -39,7 +55,15 @@ case
   0 then true
   _ then false
 //│ JS:
-//│ (caseScrut) => { if (caseScrut === 0) { return true; } else { return false; } }
+//│ (...args) => {
+//│   globalThis.Predef.checkArgs("", 1, args.length);
+//│   let caseScrut = args[0];
+//│   if (caseScrut === 0) {
+//│     return true;
+//│   } else {
+//│     return false;
+//│   }
+//│ }
 //│ = [Function (anonymous)]
 
 class Some(value)
@@ -50,7 +74,9 @@ val isDefined = case
   Some then true
   None then false
 //│ JS:
-//│ this.isDefined = (caseScrut) => {
+//│ this.isDefined = (...args) => {
+//│   globalThis.Predef.checkArgs("", 1, args.length);
+//│   let caseScrut = args[0];
 //│   if (caseScrut instanceof this.Some.class) {
 //│     return true;
 //│   } else {

hkmc2/shared/src/test/mlscript/codegen/ClassInClass.mls

@@ -35,7 +35,9 @@ class Outer(a, b) with
 //│         tmp5 = this.i1(this$Outer.a);
 //│         globalThis.log(tmp5)
 //│       }
-//│       i1(d) {
+//│       i1(...args) {
+//│         globalThis.Predef.checkArgs("i1", 1, args.length);
+//│         let d = args[0];
 //│         return [
 //│           this$Outer.b,
 //│           this.c,
@@ -50,10 +52,15 @@ class Outer(a, b) with
 //│     tmp2 = this.i.i1(1);
 //│     globalThis.log(tmp2)
 //│   }
-//│   o1(c) {
+//│   o1(...args) {
+//│     globalThis.Predef.checkArgs("o1", 1, args.length);
+//│     let c = args[0];
 //│     return this.Inner(c);
 //│   } 
-//│   o2(c1, d) {
+//│   o2(...args1) {
+//│     globalThis.Predef.checkArgs("o2", 2, args1.length);
+//│     let c1 = args1[0];
+//│     let d = args1[1];
 //│     let tmp;
 //│     tmp = this.Inner(c1);
 //│     return tmp.i1(d);

hkmc2/shared/src/test/mlscript/codegen/ClassInFun.mls

@@ -9,7 +9,9 @@ fun test(a) =
   class C with { val x = a }
   new C
 //│ JS:
-//│ function test(a) {
+//│ function test(...args) {
+//│   globalThis.Predef.checkArgs("test", 1, args.length);
+//│   let a = args[0];
 //│   class C {
 //│     constructor() {
 //│       this.x = a;
@@ -29,7 +31,9 @@ fun test(x) =
   class Foo(a, b)
   Foo(x, x + 1)
 //│ JS:
-//│ function test(x) {
+//│ function test(...args) {
+//│   globalThis.Predef.checkArgs("test", 1, args.length);
+//│   let x = args[0];
 //│   let tmp;
 //│   function Foo(a1, b1) { return new Foo.class(a1, b1); };
 //│   Foo.class = class Foo {
@@ -51,7 +55,8 @@ test(123)
 
 
 // * Forgot to pass the arg:
+:re
 test()
-//│ = Foo { a: undefined, b: NaN }
+//│ ═══[RUNTIME ERROR] Error: Function 'test' expected 1 arguments but got 0