Minor changes

Author: NeilKleistGao

shared/src/main/scala/mlscript/JSBackend.scala

@@ -308,7 +308,7 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
       else Blk(stmts.map {
         case t: Term =>
           desugarQuote(t)(blkScope, isQuoted, freeVars)
-        case s => desugarStatementForQuote(s)(blkScope, isQuoted, freeVars)
+        case s => desugarStatementInUnquote(s)(blkScope, freeVars)
       })
     case Tup(eles) =>
       def toVar(b: Bool) = if (b) Var("true") else Var("false")
@@ -349,23 +349,28 @@ abstract class JSBackend(allowUnresolvedSymbols: Bool) {
       throw CodeGenError("this quote syntax is not supported yet.")
   }
 
-  private def desugarStatementForQuote(s: Statement)(implicit scope: Scope, isQuoted: Bool, freeVars: FreeVars): Statement = s match {
-    case nd @ NuFunDef(isLetRec, nme, symbol, tparams, rhs) =>
-      NuFunDef(isLetRec, nme, symbol, tparams, rhs match {
-        case L(t) => L(desugarQuote(t))
-        case R(t) => R(t)
-      })(nd.declareLoc, nd.virtualLoc, nd.mutLoc, nd.signature, nd.outer, nd.genField)
-    case nt @ NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, superAnnot, thisAnnot, TypingUnit(body)) =>
-      NuTypeDef(kind, nme, tparams, params, ctor.map(c => desugarStatementForQuote(c) match {
-        case c: Constructor => c
+  // * Statements inside **Unquote** can refer to quoted code fragments.
+  // * Desugar them recursively.
+  private def desugarStatementInUnquote(s: Statement)(implicit scope: Scope, freeVars: FreeVars): Statement = {
+    implicit val isQuoted: Bool = false
+    s match {
+      case nd @ NuFunDef(isLetRec, nme, symbol, tparams, rhs) =>
+        NuFunDef(isLetRec, nme, symbol, tparams, rhs match {
+          case L(t) => L(desugarQuote(t))
+          case R(t) => R(t)
+        })(nd.declareLoc, nd.virtualLoc, nd.mutLoc, nd.signature, nd.outer, nd.genField)
+      case nt @ NuTypeDef(kind, nme, tparams, params, ctor, sig, parents, superAnnot, thisAnnot, TypingUnit(body)) =>
+        NuTypeDef(kind, nme, tparams, params, ctor.map(c => desugarStatementInUnquote(c) match {
+          case c: Constructor => c
+          case _ => die
+        }), sig, parents.map(p => desugarQuote(p)), superAnnot, thisAnnot, TypingUnit(body.map(s => desugarStatementInUnquote(s))))(nt.declareLoc, nt.abstractLoc)
+      case Constructor(ps, body) => Constructor(ps, desugarQuote(body) match {
+        case b: Blk => b
         case _ => die
-      }), sig, parents.map(p => desugarQuote(p)), superAnnot, thisAnnot, TypingUnit(body.map(s => desugarStatementForQuote(s))))(nt.declareLoc, nt.abstractLoc)
-    case Constructor(ps, body) => Constructor(ps, desugarQuote(body) match {
-      case b: Blk => b
-      case _ => die
-    })
-    case t: Term => desugarQuote(t)
-    case _: LetS | _: DataDefn | _: DatatypeDefn | _: TypeDef | _: Def => die // * Impossible. newDef is true
+      })
+      case t: Term => desugarQuote(t)
+      case _: LetS | _: DataDefn | _: DatatypeDefn | _: TypeDef | _: Def => die // * Impossible. newDef is true
+    }
   }
 
   /**

shared/src/test/diff/qq/Codegen.mls

@@ -365,23 +365,67 @@ class Ref[A](init: A) { mut val value: A = init }
 //│ }
 
 :ne
+:js
 x `=>
   let v = Ref(x)
   let _ = y `=>
     set v.value = y
     `0
   v.value
 //│ Code[forall 'a. 'a -> 'a, ??y & ~??x]
+//│ // Prelude
+//│ class TypingUnit30 {}
+//│ const typing_unit30 = new TypingUnit30;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   let v = Ref(Var(x1));
+//│   let _ = ((y1) => Lam(Var(y1), (() => {
+//│     void(v.value = Var(y1));
+//│     return IntLit(0);
+//│   })()))(freshName("y"));
+//│   return v.value;
+//│ })()))(freshName("x"));
+//│ // End of generated code
 
 :ne
+:js
 x `=>
   class A(y: Code[Int, nothing]) {
     val z = x `+ y
   }
   A(`0).z
 //│ Code[Int -> Int, nothing]
+//│ // Prelude
+//│ class TypingUnit31 {}
+//│ const typing_unit31 = new TypingUnit31;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const A = (() => {
+//│     class A {
+//│       #y;
+//│       #z;
+//│       get z() { return this.#z; }
+//│       constructor(y) {
+//│         this.#y = y;
+//│         this.#z = App(Var("+"), Var(x1), y);
+//│         const z = this.#z;
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [x.#y];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = ((y) => new A(y));
+//│     ctor.class = A;
+//│     return ctor;
+//│   })();
+//│   return A(IntLit(0)).z;
+//│ })()))(freshName("x"));
+//│ // End of generated code
 
 :ne
+:js
 x `=>
   class A() {
     constructor() {
@@ -390,12 +434,59 @@ x `=>
   }
   new A(), x
 //│ Code[forall 'a. 'a -> 'a, nothing]
+//│ // Prelude
+//│ class TypingUnit32 {}
+//│ const typing_unit32 = new TypingUnit32;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const A = (() => {
+//│     class A {
+//│       constructor() {
+//│         log(Var(x1));
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = (() => new A());
+//│     ctor.class = A;
+//│     return ctor;
+//│   })();
+//│   return new A.class() , Var(x1);
+//│ })()))(freshName("x"));
+//│ // End of generated code
 
 class Foo(x: Code[Int, anything])
 //│ class Foo(x: Code[Int, anything])
 
 :ne
+:js
 x `=>
   class B() extends Foo(x)
   `x
 //│ Code[forall 'a. (Int & 'a) -> 'a, nothing]
+//│ // Prelude
+//│ class TypingUnit34 {}
+//│ const typing_unit34 = new TypingUnit34;
+//│ // Query 1
+//│ res = ((x1) => Lam(Var(x1), (() => {
+//│   const B = (() => {
+//│     class B extends Foo.class {
+//│       constructor() {
+//│         super(Var(x1));
+//│       }
+//│     static
+//│       unapply(x) {
+//│         return [];
+//│       }
+//│     }
+//│     let ctor;
+//│     ctor = (() => new B());
+//│     ctor.class = B;
+//│     return ctor;
+//│   })();
+//│   return Var(x1);
+//│ })()))(freshName("x"));
+//│ // End of generated code