Add additional test cases (hkust-taco#296)

Co-authored-by: Lionel Parreaux <lionel.parreaux@gmail.com>

Author: AnsonYeung

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

@@ -613,6 +613,12 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
         case Assign(t: TermSymbol, rhs, rest) if t.owner.isDefined =>
           ctx.getIsymPath(t.owner.get) match
             case Some(value) if !belongsToCtor(t.owner.get) =>
+              if (t.k is syntax.LetBind) && !t.owner.forall(_.isInstanceOf[semantics.TopLevelSymbol]) then
+                // TODO: improve the error message
+                raise(ErrorReport(
+                  msg"Uses of private fields cannot yet be lifted." -> N :: Nil,
+                  N, Diagnostic.Source.Compilation
+                ))
               AssignField(value.asPath, t.id, applyResult(rhs), applyBlock(rest))(N)
             case _ => super.applyBlock(rewritten)
 
@@ -623,6 +629,12 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
             case None => super.applyBlock(rewritten)
             case Some(value) => Assign(value, applyResult(rhs), applyBlock(rest))
 
+        case Define(d: ValDefn, rest: Block) if d.owner.isDefined =>
+          ctx.getIsymPath(d.owner.get) match
+            case Some(value) if !belongsToCtor(d.owner.get) =>
+              AssignField(value.asPath, Tree.Ident(d.sym.nme), applyResult(d.rhs), applyBlock(rest))(S(d.sym))
+            case _ => super.applyBlock(rewritten)
+        
         case Define(d: Defn, rest: Block) => ctx.modLocals.get(d.sym) match 
           case Some(sym) if !ctx.ignored(d.sym) => ctx.getBmsReqdInfo(d.sym) match
             case Some(_) => 
@@ -650,7 +662,14 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
         case _ => super.applyPath(p)
       case Value.Ref(t: TermSymbol) if t.owner.isDefined =>
         ctx.getIsymPath(t.owner.get) match
-          case Some(value) if !belongsToCtor(t.owner.get) => Select(value.asPath, t.id)(N)
+          case Some(value) if !belongsToCtor(t.owner.get) =>
+            if (t.k is syntax.LetBind) && !t.owner.forall(_.isInstanceOf[semantics.TopLevelSymbol]) then
+              // TODO: improve the error message
+              raise(ErrorReport(
+                msg"Uses of private fields cannot yet be lifted." -> N :: Nil,
+                N, Diagnostic.Source.Compilation
+              ))
+            Select(value.asPath, t.id)(N)
           case _ => super.applyPath(p)
 
       // Rewrites this.className.class to reference the top-level definition
@@ -885,7 +904,7 @@ class Lifter(handlerPaths: Opt[HandlerPaths])(using State, Raise):
     val newCtx_ = ctxx
       .addLocalPaths(nestedClsPaths)
       .addLocalPaths(getVars(c).map(s => s -> s).toMap)
-      .addIgnoredBmsPaths(ctorIgnored.map(d => d.sym -> Select(c.isym.asPath, Tree.Ident(d.sym.nme))(S(d.sym))).toMap)
+      .addIgnoredBmsPaths(ctorIgnored.map(d => d.sym -> d.sym.asPath).toMap)
 
     val newCtx = c.k match
       case syntax.Mod if !ctx.ignored(c.sym) => newCtx_

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

@@ -62,10 +62,10 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case ts: semantics.TermSymbol =>
       ts.owner match
       case S(owner) =>
-        doc"${getVar(owner)}.${
+        doc"${getVar(owner)}${
           if (ts.k is syntax.LetBind) && !owner.isInstanceOf[semantics.TopLevelSymbol]
-          then "#" + owner.privatesScope.lookup_!(ts)
-          else ts.id.name
+          then ".#" + owner.privatesScope.lookup_!(ts)
+          else fieldSelect(ts.id.name)
         }"
       case N => summon[Scope].lookup_!(ts)
     case ts: semantics.InnerSymbol =>
@@ -86,6 +86,12 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case _: Value.Lam => doc"(${result(r)})"
     case _ => result(r)
 
+  def fieldSelect(s: Str): Document =
+    if JSBuilder.isValidFieldName(s) then doc".$s"
+    else s.toIntOption match
+      case S(index) => s"[$index]"
+      case N => s"[${JSBuilder.makeStringLiteral(s)}]"
+  
   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)
@@ -161,7 +167,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
     case Assign(l, r, rst) =>
       doc" # ${getVar(l)} = ${result(r)};${returningTerm(rst, endSemi)}"
     case AssignField(p, n, r, rst) =>
-      doc" # ${result(p)}.${n.name} = ${result(r)};${returningTerm(rst, endSemi)}"
+      doc" # ${result(p)}${fieldSelect(n.name)} = ${result(r)};${returningTerm(rst, endSemi)}"
     case AssignDynField(p, f, ai, r, rst) =>
       doc" # ${result(p)}[${result(f)}] = ${result(r)};${returningTerm(rst, endSemi)}"
     case Define(defn, rst) =>
@@ -176,7 +182,7 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
         case N =>
           doc"${getVar(sym)} = ${result(p)};${returningTerm(rst, endSemi)}"
         case S(owner) =>
-          doc"${mkThis(owner)}.${sym.nme} = ${result(p)};${returningTerm(rst, endSemi)}"
+          doc"${mkThis(owner)}${fieldSelect(sym.nme)} = ${result(p)};${returningTerm(rst, endSemi)}"
       case defn: (FunDefn | ClsLikeDefn) =>
         val outerScope = scope
         val (thisProxy, res) = scope.nestRebindThis(
@@ -218,19 +224,28 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                 .mkDocument(doc"")
             val preCtorCode = ctorAuxParams.flatMap(ps => ps).foldLeft(body(preCtor, endSemi = true)):
               case (acc, (sym, nme)) =>
-                doc"$acc # this.${sym.name} = $nme;"
-            val ctorCode = doc"$preCtorCode${body(ctor, endSemi = false)}"
+                doc"$acc # this${fieldSelect(sym.name)} = $nme;"
+            val ctorCode = doc"$preCtorCode${body(ctor, endSemi = auxParams.nonEmpty)}"
 
-            val ctorBod = if auxParams.isEmpty then
-              doc"${braced(ctorCode)}"
+            val ctorAux = if auxParams.isEmpty then
+              ctorCode
             else
               val pss = ctorAuxParams.map(_.map(_._2))
               val newCtorCode = doc"$ctorCode # return this;"
               val ctorBraced = doc"${ braced(newCtorCode) }"
               val funBod = pss.foldRight(ctorBraced):
                 case (psDoc, doc) => doc"(${psDoc.mkDocument(", ")}) => $doc"
 
-              doc"${ braced(doc" # return $funBod") }"
+              doc" # return $funBod"
+            
+            val ctorBod = if isModule then
+              ownr match
+              case S(owner) =>
+                braced(doc" # ${result(Value.Ref(owner))}.${sym.nme} = ${getVar(isym)};$ctorCode")
+              case N =>
+                braced(doc" # ${getVar(sym)} = ${getVar(isym)};$ctorCode")
+            else
+              braced(ctorAux)
 
             val ctorOrStatic = if isModule
               then doc"static"
@@ -271,10 +286,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("\"\"")("globalThis.Predef.render(this." + _._1.name + ")")
+                      ctorFields.headOption.fold("\"\"")(f => "globalThis.Predef.render(this" + fieldSelect(f._1.name) + ")")
                     }${
-                      ctorFields.tailOption.fold("")(_.map(
-                        """ + ", " + globalThis.Predef.render(this.""" + _._1.name + ")").mkString)
+                      ctorFields.tailOption.fold("")(_.map(f =>
+                        """ + ", " + globalThis.Predef.render(this""" + fieldSelect(f._1.name) + ")").mkString)
                     } + ")""""
                 }; }"""
               } #}  # }"
@@ -285,13 +300,13 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
                 assert((kind is syntax.Pat) || paramsOpt.isEmpty)
                 // doc"${mkThis(owner)}.${sym.nme} = new ${clsJS}"
                 if isModule
-                then doc"${mkThis(owner)}.${sym.nme} = ${clsJS};"
+                then doc"(${clsJS});"
                 else doc"const $clsTmp = ${clsJS}; # ${mkThis(owner)}.${sym.nme} = new ${clsTmp
                   }; # ${mkThis(owner)}.${sym.nme}.class = $clsTmp;"
               case N =>
                 val v = getVar(sym)
                 if isModule
-                then doc"${v} = ${clsJS};"
+                then doc"(${clsJS});"
                 else doc"const $clsTmp = ${clsJS}; ${v} = new ${clsTmp
                   }; # ${v}.class = $clsTmp;"
             else

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

@@ -4,8 +4,10 @@ let privFun, Example1;
 privFun = function privFun() {
   return "hi"
 };
-Example1 = class Example {
-  static {}
+(class Example {
+  static {
+    Example1 = Example;
+  }
   static get pubFun() {
     let tmp;
     tmp = privFun();
@@ -29,5 +31,5 @@ Example1 = class Example {
     }
   }
   static toString() { return "Example"; }
-};
+});
 let Example = Example1; export default Example;

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

@@ -24,8 +24,9 @@ Iterator1.class = class Iterator {
   }
   toString() { return "Iterator(" + globalThis.Predef.render(this.next) + ")"; }
 };
-Result1 = class Result {
+(class Result {
   static {
+    Result1 = Result;
     this.Next = function Next(value1) {
       return new Next.class(value1);
     };
@@ -46,9 +47,11 @@ Result1 = class Result {
     this.Done.class = Done$class;
   }
   static toString() { return "Result"; }
-};
-Iter1 = class Iter {
-  static {}
+});
+(class Iter {
+  static {
+    Iter1 = Iter;
+  }
   static getIterator(something) {
     let test, prototype, tmp, tmp1;
     test = something[globalThis.Symbol.iterator];
@@ -474,5 +477,5 @@ Iter1 = class Iter {
     return Iter.rightFolded(xs12, Stack.Nil, Stack.Cons)
   }
   static toString() { return "Iter"; }
-};
+});
 let Iter = Iter1; export default Iter;

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

@@ -1,8 +1,9 @@
 import runtime from "./Runtime.mjs";
 import Predef from "./Predef.mjs";
 let Option1;
-Option1 = class Option {
+(class Option {
   static {
+    Option1 = Option;
     this.Some = function Some(value1) {
       return new Some.class(value1);
     };
@@ -28,8 +29,10 @@ Option1 = class Option {
       }
       toString() { return "Both(" + globalThis.Predef.render(this.fst) + ", " + globalThis.Predef.render(this.snd) + ")"; }
     };
-    this.unsafe = class unsafe {
-      static {}
+    (class unsafe {
+      static {
+        Option.unsafe = unsafe;
+      }
       static get(opt) {
         let param0, value;
         if (opt instanceof Option.Some.class) {
@@ -43,7 +46,7 @@ Option1 = class Option {
         }
       }
       static toString() { return "unsafe"; }
-    };
+    });
   }
   static isDefined(x) {
     if (x instanceof Option.Some.class) {
@@ -70,5 +73,5 @@ Option1 = class Option {
     }
   }
   static toString() { return "Option"; }
-};
+});
 let Option = Option1; export default Option;

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

@@ -2,8 +2,9 @@ import runtime from "./Runtime.mjs";
 import Runtime from "./Runtime.mjs";
 import Rendering from "./Rendering.mjs";
 let Predef1;
-Predef1 = class Predef {
+(class Predef {
   static {
+    Predef1 = Predef;
     this.pass1 = Rendering.pass1;
     this.pass2 = Rendering.pass2;
     this.pass3 = Rendering.pass3;
@@ -14,8 +15,9 @@ Predef1 = class Predef {
     this.render = Rendering.render;
     this.assert = globalThis.console.assert;
     this.foldl = Predef.fold;
-    this.TraceLogger = class TraceLogger {
+    (class TraceLogger {
       static {
+        Predef.TraceLogger = TraceLogger;
         this.enabled = false;
         this.indentLvl = 0;
       }
@@ -56,7 +58,7 @@ Predef1 = class Predef {
         }
       }
       static toString() { return "TraceLogger"; }
-    };
+    });
     this.Test = class Test {
       constructor() {
         let tmp;
@@ -259,5 +261,5 @@ Predef1 = class Predef {
     return Runtime.mkEffect(Runtime.FatalEffect, null)
   }
   static toString() { return "Predef"; }
-};
+});
 let Predef = Predef1; export default Predef;

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

@@ -1,7 +1,9 @@
 import runtime from "./Runtime.mjs";
 let Rendering1;
-Rendering1 = class Rendering {
-  static {}
+(class Rendering {
+  static {
+    Rendering1 = Rendering;
+  }
   static pass1(f) {
     return (...xs) => {
       return runtime.safeCall(f(xs[0]))
@@ -233,5 +235,5 @@ Rendering1 = class Rendering {
     }
   }
   static toString() { return "Rendering"; }
-};
+});
 let Rendering = Rendering1; export default Rendering;

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

@@ -2,8 +2,9 @@ import runtime from "./Runtime.mjs";
 import RuntimeJS from "./RuntimeJS.mjs";
 import Rendering from "./Rendering.mjs";
 let Runtime1;
-Runtime1 = class Runtime {
+(class Runtime {
   static {
+    Runtime1 = Runtime;
     const Unit$class = class Unit {
       constructor() {}
       toString() {
@@ -696,5 +697,5 @@ Runtime1 = class Runtime {
     return result
   }
   static toString() { return "Runtime"; }
-};
+});
 let Runtime = Runtime1; export default Runtime;

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

@@ -1,8 +1,9 @@
 import runtime from "./Runtime.mjs";
 import Predef from "./Predef.mjs";
 let Stack1;
-Stack1 = class Stack {
+(class Stack {
   static {
+    Stack1 = Stack;
     this.Cons = function Cons(head1, tail1) {
       return new Cons.class(head1, tail1);
     };
@@ -206,5 +207,5 @@ Stack1 = class Stack {
     }
   }
   static toString() { return "Stack"; }
-};
+});
 let Stack = Stack1; export default Stack;

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

@@ -1,7 +1,9 @@
 import runtime from "./Runtime.mjs";
 let Str1;
-Str1 = class Str {
-  static {}
+(class Str {
+  static {
+    Str1 = Str;
+  }
   static concat2(a, b) {
     return a + b
   } 
@@ -21,5 +23,5 @@ Str1 = class Str {
     }
   }
   static toString() { return "Str"; }
-};
+});
 let Str = Str1; export default Str;

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

@@ -12,8 +12,10 @@ StyleAttributeValue1.class = class StyleAttributeValue {
   }
   toString() { return "StyleAttributeValue(" + "" + ")"; }
 };
-XML1 = class XML {
-  static {}
+(class XML {
+  static {
+    XML1 = XML;
+  }
   static serializeValue(value) {
     let param0, rules, tmp, tmp1, tmp2, lambda;
     if (typeof value === 'string') {
@@ -106,5 +108,5 @@ XML1 = class XML {
     }
   }
   static toString() { return "XML"; }
-};
+});
 let XML = XML1; export default XML;