Show diff-test results using MLscript pretty-printer instead of NodeJS console output

Author: LPTK

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

@@ -57,7 +57,7 @@ sealed abstract class Block extends Product with AutoLocated:
     case HandleBlock(lhs, res, par, cls, handlers, bdy, rst) => 1 + handlers.map(_.body.size).sum + bdy.size + rst.size
 
   // TODO conserve if no changes
-  def mapTail(f: BlockTail => BlockTail): Block = this match
+  def mapTail(f: BlockTail => Block): Block = this match
     case b: BlockTail => f(b)
     case Begin(sub, rst) => Begin(sub, rst.mapTail(f))
     case Assign(lhs, rhs, rst) => Assign(lhs, rhs, rst.mapTail(f))
@@ -68,6 +68,13 @@ sealed abstract class Block extends Product with AutoLocated:
       Match(scrut, arms.map(_ -> _.mapTail(f)), dflt.map(_.mapTail(f)), rst)
     case Match(scrut, arms, dflt, rst) =>
       Match(scrut, arms, dflt, rst.mapTail(f))
+    case Label(label, body, rest) => Label(label, body, rest.mapTail(f))
+    case af @ AssignField(lhs, nme, rhs, rest) =>
+      AssignField(lhs, nme, rhs, rest.mapTail(f))(af.symbol)
+    case adf @ AssignDynField(lhs, fld, arrayIdx, rhs, rest) =>
+      AssignDynField(lhs, fld, arrayIdx, rhs, rest.mapTail(f))
+    case tb @ TryBlock(sub, fin, rest) =>
+      TryBlock(sub, fin, rest.mapTail(f))
 
   lazy val freeVars: Set[Local] = this match
     case Match(scrut, arms, dflt, rest) =>
@@ -143,7 +150,7 @@ case class Return(res: Result, implct: Bool) extends BlockTail
 
 case class Throw(exc: Result) extends BlockTail
 
-case class Label(label: Local, body: Block, rest: Block) extends BlockTail
+case class Label(label: Local, body: Block, rest: Block) extends Block
 
 case class Break(label: Local) extends BlockTail
 case class Continue(label: Local) extends BlockTail
@@ -276,7 +283,8 @@ case class Call(fun: Path, args: Ls[Arg])(val isMlsFun: Bool) extends Result
 case class Instantiate(cls: Path, args: Ls[Path]) extends Result
 
 sealed abstract class Path extends Result:
-  def selN(id: Tree.Ident) = Select(this, id)(N)
+  def selN(id: Tree.Ident): Path = Select(this, id)(N)
+  def selSN(id: Str): Path = selN(new Tree.Ident(id))
   def asArg = Arg(false, this)
 
 case class Select(qual: Path, name: Tree.Ident)(val symbol: Opt[FieldSymbol]) extends Path with ProductWithExtraInfo:

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

@@ -24,7 +24,7 @@ object Elaborator:
     "==", "!=", "<", "<=", ">", ">=",
     "===", "!==",
     "&&", "||")
-  val unaryOps = Set("-", "+", "!", "~")
+  val unaryOps = Set("-", "+", "!", "~", "typeof")
   val anyOps = Set("super")
   val builtins = binaryOps ++ unaryOps ++ anyOps
   val aliasOps = Map(

hkmc2/shared/src/main/scala/hkmc2/utils/ReplHost.scala

@@ -108,10 +108,8 @@ class ReplHost(rootPath: Str)(using TL) {
     // Send the code
     send(wrapped)
     (parseQueryResult() match
-      case intermediate: Str =>
-        val lines = intermediate.splitSane('\n')
-        val result = lines.lastOption.getOrElse("")
-        ReplHost.Result(result, if lines.size < 2 then N else S(lines.init.mkString("\n")))
+      case output: Str =>
+        ReplHost.Result(output)
       case error: ReplHost.Error => error
     , consumeStderr())
 
@@ -124,7 +122,7 @@ class ReplHost(rootPath: Str)(using TL) {
   def execute(code: Str): ReplHost.Reply = {
     send(code)
     collectUntilPrompt() match
-    case res: Str => ReplHost.Result(res, None)
+    case res: Str => ReplHost.Result(res)
     case error: ReplHost.Error => error
   }
 
@@ -160,15 +158,10 @@ object ReplHost {
     * Represents a successful reply from Node.js.
     *
     * @param content the reply content, i.e. the final result
-    * @param intermediate the intermediate evaluation results
     */
-  final case class Result(content: Str, intermediate: Opt[Str]) extends Reply {
+  final case class Result(content: Str) extends Reply {
     override def map(f: Str => Reply): Reply = f(content)
-    override def toString(): Str = s"[success] $content${
-      intermediate match
-        case None | Some("") => s""
-        case Some(str) => s" (with output)"
-    }"
+    override def toString(): Str = s"[success] $content"
   }
 
   /**

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

@@ -195,6 +195,11 @@ Predef1 = class Predef {
     tmp1 = tmp(...xs) ?? null;
     return globalThis.console.log(...tmp1) ?? null;
   } 
+  static printRaw(x4) {
+    let tmp;
+    tmp = Predef.render(x4);
+    return globalThis.console.log(tmp) ?? null;
+  } 
   static interleave(sep) {
     return (...args) => {
       let res, len, i, scrut, idx, scrut1, scrut2, tmp, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
@@ -243,21 +248,95 @@ Predef1 = class Predef {
     }
   } 
   static render(arg1) {
-    let tmp, tmp1, tmp2, tmp3, tmp4;
-    if (arg1 instanceof globalThis.Array) {
-      tmp = Predef.fold((arg11, arg2) => {
-        return arg11 + arg2;
-      });
-      tmp1 = Predef.interleave(", ");
-      tmp2 = Predef.map(Predef.render);
-      tmp3 = tmp2(...arg1) ?? null;
-      tmp4 = tmp1(...tmp3) ?? null;
-      return tmp("[", ...tmp4, "]") ?? null;
+    let ts, p, scrut, scrut1, scrut2, nme, tmp, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, tmp16, tmp17, tmp18, tmp19, tmp20;
+    if (arg1 === undefined) {
+      return "undefined";
     } else {
-      if (typeof arg1 === 'string') {
-        return globalThis.JSON.stringify(arg1) ?? null;
+      if (arg1 === null) {
+        return "null";
       } else {
-        return globalThis.String(arg1);
+        if (arg1 instanceof globalThis.Array) {
+          tmp = Predef.fold((arg11, arg2) => {
+            return arg11 + arg2;
+          });
+          tmp1 = Predef.interleave(", ");
+          tmp2 = Predef.map(Predef.render);
+          tmp3 = tmp2(...arg1) ?? null;
+          tmp4 = tmp1(...tmp3) ?? null;
+          return tmp("[", ...tmp4, "]") ?? null;
+        } else {
+          if (typeof arg1 === 'string') {
+            return globalThis.JSON.stringify(arg1) ?? null;
+          } else {
+            if (arg1 instanceof globalThis.Set) {
+              tmp5 = Predef.fold((arg11, arg2) => {
+                return arg11 + arg2;
+              });
+              tmp6 = Predef.interleave(", ");
+              tmp7 = Predef.map(Predef.render);
+              tmp8 = tmp7(...arg1) ?? null;
+              tmp9 = tmp6(...tmp8) ?? null;
+              return tmp5("Set{", ...tmp9, "}") ?? null;
+            } else {
+              if (arg1 instanceof globalThis.Map) {
+                tmp10 = Predef.fold((arg11, arg2) => {
+                  return arg11 + arg2;
+                });
+                tmp11 = Predef.interleave(", ");
+                tmp12 = Predef.map(Predef.render);
+                tmp13 = tmp12(...arg1) ?? null;
+                tmp14 = tmp11(...tmp13) ?? null;
+                return tmp10("Map{", ...tmp14, "}") ?? null;
+              } else {
+                if (arg1 instanceof globalThis.Function) {
+                  p = globalThis.Object.getOwnPropertyDescriptor(arg1, "prototype");
+                  if (p instanceof globalThis.Object) {
+                    scrut = p["writable"];
+                    if (scrut === true) {
+                      tmp15 = true;
+                    } else {
+                      tmp15 = false;
+                    }
+                  } else {
+                    tmp15 = false;
+                  }
+                  if (p === undefined) {
+                    tmp16 = true;
+                  } else {
+                    tmp16 = false;
+                  }
+                  scrut1 = tmp15 || tmp16;
+                  if (scrut1 === true) {
+                    scrut2 = arg1.name;
+                    if (scrut2 === "") {
+                      tmp17 = "";
+                    } else {
+                      nme = scrut2;
+                      tmp17 = " " + nme;
+                    }
+                    tmp18 = "[function" + tmp17;
+                    return tmp18 + "]";
+                  } else {
+                    return globalThis.String(arg1);
+                  }
+                } else {
+                  if (arg1 instanceof globalThis.Object) {
+                    return globalThis.String(arg1);
+                  } else {
+                    ts = arg1["toString"];
+                    if (ts === undefined) {
+                      tmp19 = typeof arg1;
+                      tmp20 = "[" + tmp19;
+                      return tmp20 + "]";
+                    } else {
+                      return ts.call(arg1) ?? null;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
       }
     }
   } 

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

@@ -24,6 +24,9 @@ fun pass3(f)(...xs) = f(xs.0, xs.1, xs.2)
 fun print(...xs) =
   console.log(...map(renderAsStr)(...xs))
 
+fun printRaw(x) =
+  console.log(render(x))
+
 fun interleave(sep)(...args) =
   if args.length === 0 then [] else...
   let
@@ -41,10 +44,25 @@ fun interleave(sep)(...args) =
 fun renderAsStr(arg) =
   if arg is Str then arg else render(arg)
 
-fun render(arg) = if arg is
-  Array then fold(+)("[", ...interleave(", ")(...map(render)(...arg)), "]")
-  Str then JSON.stringify(arg)
-  else String(arg)
+fun render(arg) = if
+  arg is
+    undefined then "undefined"
+    null      then "null"
+    Array     then fold(+)("[", ...interleave(", ")(...map(render)(...arg)), "]")
+    Str       then JSON.stringify(arg)
+    Set       then fold(+)("Set{", ...interleave(", ")(...map(render)(...arg)), "}")
+    Map       then fold(+)("Map{", ...interleave(", ")(...map(render)(...arg)), "}")
+    Function  and
+      let p = Object.getOwnPropertyDescriptor(arg, "prototype")
+      (p is Object and p.("writable")) || (p is undefined) then
+        "[function" + (if arg.name is
+          "" then ""
+          nme then " " + nme
+        ) + "]"
+    Object    then String(arg)
+  let ts = arg.("toString") // not accessing as `arg.toString` to avoid the sanity check
+  ts is undefined then "[" + typeof(arg) + "]"
+  else ts.call(arg)
 
 val assert = console.assert
 

hkmc2/shared/src/test/mlscript/apps/AccountingTest.mls

@@ -4,33 +4,15 @@ import "../../mlscript-compile/apps/Accounting.mls"
 
 
 val acc = new Accounting
-//│ > Accounting {
-//│ >   warnings: [],
-//│ >   Project: [Function: Project] { class: [class Project] },
-//│ >   Line: [Function: Line] { class: [class Line] },
-//│ >   lines: [],
-//│ >   Report: [Function: Report] { class: [class Report] }
-//│ acc = }
+//│ acc = Accounting
 
 val proj = acc.Project("P1")
-//│ proj = Project { num: 'P1' }
+//│ proj = Project("P1")
 
 val l1 = acc.mkLine("L1", proj, 200_000, true)
 val l2 = acc.mkLine("L2", proj, 1_000_000, true)
-//│ > Line {
-//│ >   name: 'L1',
-//│ >   proj: Project { num: 'P1' },
-//│ >   starting_balance: 200000,
-//│ >   isMatchable: true,
-//│ >   balance: 200000
-//│ l1 = }
-//│ > Line {
-//│ >   name: 'L2',
-//│ >   proj: Project { num: 'P1' },
-//│ >   starting_balance: 1000000,
-//│ >   isMatchable: true,
-//│ >   balance: 1000000
-//│ l2 = }
+//│ l1 = Line("L1", Project("P1"), 200000, true)
+//│ l2 = Line("L2", Project("P1"), 1000000, true)
 
 
 :...

hkmc2/shared/src/test/mlscript/apps/CSVTest.mls

@@ -4,37 +4,28 @@ import "../../mlscript-compile/apps/CSV.mls"
 
 
 let csv = CSV()
-//│ > CSV {
-//│ >   strDelimiter: ',',
-//│ >   objPattern: /(\,|\r?\n|\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\,\r\n]*))/gi
-//│ csv = }
+//│ csv = CSV(",")
 
 csv.strDelimiter
-//│ = ','
+//│ = ","
 
 csv.objPattern
 //│ = /(\,|\r?\n|\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\,\r\n]*))/gi
 
 csv.toArrays("a,b,c")
-//│ = [ [ 'a', 'b', 'c' ] ]
+//│ = [["a", "b", "c"]]
 
 csv.toArrays("a,b,c\n1,2,3\n4,5,6")
-//│ = [ [ 'a', 'b', 'c' ], [ '1', '2', '3' ], [ '4', '5', '6' ] ]
+//│ = [["a", "b", "c"], ["1", "2", "3"], ["4", "5", "6"]]
 
 csv.toArrays("a,b,c\n\n1,2,3\n4,5,6\n")
-//│ > [
-//│ >   [ 'a', 'b', 'c' ],
-//│ >   [ '' ],
-//│ >   [ '1', '2', '3' ],
-//│ >   [ '4', '5', '6' ],
-//│ >   [ '' ]
-//│ = ]
+//│ = [["a", "b", "c"], [""], ["1", "2", "3"], ["4", "5", "6"], [""]]
 
 csv.toArrays(",")
-//│ = [ [ '' ] ]
+//│ = [[""]]
 
 csv.toArrays(",,")
-//│ = [ [ '', '' ] ]
+//│ = [["", ""]]