json-as 1.1.10 → 1.1.12

package/transform/src/index.ts

@@ -1,12 +1,13 @@
-import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, Tokenizer, SourceKind, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression, MethodDeclaration, Statement, Program, Feature, CallExpression, PropertyAccessExpression } from "assemblyscript/dist/assemblyscript.js";
+import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, SourceKind, NamedTypeNode, Range, FunctionExpression, MethodDeclaration, Program, Feature } from "assemblyscript/dist/assemblyscript.js";
 import { Transform } from "assemblyscript/dist/transform.js";
 import { Visitor } from "./visitor.js";
-import { cloneNode, isStdlib, removeExtension, replaceRef, SimpleParser, toString } from "./util.js";
+import { isStdlib, removeExtension, SimpleParser, toString } from "./util.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { Property, PropertyFlags, Schema } from "./types.js";
-import { getClass, getClasses, getImportedClass } from "./linker.js";
+import { Property, PropertyFlags, Schema, Src } from "./types.js";
+import { getClass, getImportedClass } from "./linkers/classes.js";
 import { existsSync, writeFileSync } from "fs";
+import { CustomTransform } from "./linkers/custom.js";
 
 let indent = "  ";
 
@@ -25,37 +26,6 @@ const DEBUG = rawValue === "true"
 
 const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
 
-class CustomTransform extends Visitor {
-  static SN: CustomTransform = new CustomTransform();
-
-  private modify: boolean = false;
-  visitCallExpression(node: CallExpression) {
-    super.visit(node.args, node);
-    if (node.expression.kind != NodeKind.PropertyAccess || (node.expression as PropertyAccessExpression).property.text != "stringify") return;
-    if ((node.expression as PropertyAccessExpression).expression.kind != NodeKind.Identifier || ((node.expression as PropertyAccessExpression).expression as IdentifierExpression).text != "JSON") return;
-
-    if (this.modify) {
-      (node.expression as PropertyAccessExpression).expression = Node.createPropertyAccessExpression(Node.createIdentifierExpression("JSON", node.expression.range), Node.createIdentifierExpression("internal", node.expression.range), node.expression.range);
-    }
-    this.modify = true;
-
-    // console.log(toString(node));
-    // console.log(SimpleParser.parseStatement("JSON.internal.stringify").expression.expression)
-  }
-  static visit(node: Node | Node[], ref: Node | null = null): void {
-    if (!node) return;
-    CustomTransform.SN.modify = true;
-    CustomTransform.SN.visit(node, ref);
-    CustomTransform.SN.modify = false;
-  }
-  static hasCall(node: Node | Node[]): boolean {
-    if (!node) return;
-    CustomTransform.SN.modify = false;
-    CustomTransform.SN.visit(node);
-    return CustomTransform.SN.modify;
-  }
-}
-
 class JSONTransform extends Visitor {
   static SN: JSONTransform = new JSONTransform();
 
@@ -64,14 +34,24 @@ class JSONTransform extends Visitor {
   public parser!: Parser;
   public schemas: Map<string, Schema[]> = new Map<string, Schema[]>();
   public schema!: Schema;
-  public sources = new Set<Source>();
+  public src!: Src;
+  public sources: Map<string, Src> = new Map<string, Src>();
   public imports: ImportStatement[] = [];
 
-  public topStatements: Statement[] = [];
   public simdStatements: string[] = [];
 
   private visitedClasses: Set<string> = new Set<string>();
 
+  visitClassDeclarationRef(node: ClassDeclaration): void {
+    if (
+      !node.decorators?.length ||
+      !node.decorators.some((decorator) => {
+        const name = (<IdentifierExpression>decorator.name).text;
+        return name === "json" || name === "serializable";
+      })
+    ) throw new Error("Class " + node.name.text + " is missing an @json or @serializable decorator in " + node.range.source.internalPath);
+    this.visitClassDeclaration(node);
+  }
   visitClassDeclaration(node: ClassDeclaration): void {
     if (!node.decorators?.length) return;
 
@@ -80,11 +60,16 @@ class JSONTransform extends Visitor {
         const name = (<IdentifierExpression>decorator.name).text;
         return name === "json" || name === "serializable";
       })
-    )
-      return;
+    ) return;
+
+    const source = node.range.source;
+    if (!this.sources.has(source.internalPath)) {
+      this.src = new Src(source);
+      this.sources.set(source.internalPath, this.src);
+    } else this.src = this.sources.get(source.internalPath);
 
-    if (this.visitedClasses.has(node.range.source.internalPath + node.name.text)) return;
-    if (!this.schemas.has(node.range.source.internalPath)) this.schemas.set(node.range.source.internalPath, []);
+    if (this.visitedClasses.has(source.internalPath + node.name.text)) return;
+    if (!this.schemas.has(source.internalPath)) this.schemas.set(source.internalPath, []);
 
     const members: FieldDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.FieldDeclaration && v.flags !== CommonFlags.Static && v.flags !== CommonFlags.Private && v.flags !== CommonFlags.Protected && !v.decorators?.some((decorator) => (<IdentifierExpression>decorator.name).text === "omit")) as FieldDeclaration[])];
     const serializers: MethodDeclaration[] = [...node.members.filter((v) => v.kind === NodeKind.MethodDeclaration && v.decorators && v.decorators.some((e) => (<IdentifierExpression>e.name).text.toLowerCase() === "serializer"))] as MethodDeclaration[];
@@ -99,27 +84,37 @@ class JSONTransform extends Visitor {
       if (!schema.parent) {
         const depSearch = schema.deps.find((v) => v.name == extendsName);
         if (depSearch) {
-          if (DEBUG > 0) console.log("Found " + extendsName + " in dependencies of " + node.range.source.internalPath);
-          schema.deps.push(depSearch);
-          schema.parent = depSearch
+          if (DEBUG > 0) console.log("Found " + extendsName + " in dependencies of " + source.internalPath);
+          if (!schema.deps.some(v => v.name == depSearch.name)) schema.deps.push(depSearch);
+          schema.parent = depSearch;
         } else {
-          const internalSearch = getClass(extendsName, node.range.source);
+          const internalSearch = getClass(extendsName, source);
           if (internalSearch) {
-            if (DEBUG > 0) console.log("Found " + extendsName + " internally from " + node.range.source.internalPath);
-            this.visitClassDeclaration(internalSearch);
-            schema.deps.push(this.schema);
-            this.schemas.get(node.range.source.internalPath).push(this.schema);
-            schema.parent = this.schema;
-            this.schema = schema;
+            if (DEBUG > 0) console.log("Found " + extendsName + " internally from " + source.internalPath);
+            if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+              this.visitClassDeclarationRef(internalSearch);
+              this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
+              this.visitClassDeclaration(node);
+              return;
+            }
+            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find(s => s.name == internalSearch.name.text);
+            if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
+            schema.deps.push(schem);
+            schema.parent = schem;
           } else {
-            const externalSearch = getImportedClass(extendsName, node.range.source, this.parser);
+            const externalSearch = getImportedClass(extendsName, source, this.parser);
             if (externalSearch) {
-              if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + node.range.source.internalPath);
-              this.visitClassDeclaration(externalSearch);
-              schema.deps.push(this.schema);
-              this.schemas.get(node.range.source.internalPath).push(this.schema);
-              schema.parent = this.schema;
-              this.schema = schema;
+              if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
+              if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+                this.visitClassDeclarationRef(externalSearch);
+                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                this.visitClassDeclaration(node);
+                return;
+              }
+              const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find(s => s.name == externalSearch.name.text);
+              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+              schema.deps.push(schem);
+              schema.parent = schem;
             }
           }
         }
@@ -136,6 +131,7 @@ class JSONTransform extends Visitor {
 
     const getUnknownTypes = (type: string, types: string[] = []): string[] => {
       type = stripNull(type);
+      type = this.src.aliases.find(v => stripNull(v.name) == type)?.getBaseType() || type;
       if (type.startsWith("Array<")) {
         return getUnknownTypes(type.slice(6, -1));
       } else if (type.startsWith("Map<")) {
@@ -161,33 +157,43 @@ class JSONTransform extends Visitor {
       for (const unknownType of unknown) {
         const depSearch = schema.deps.find((v) => v.name == unknownType);
         if (depSearch) {
-          if (DEBUG > 0) console.log("Found " + unknownType + " in dependencies of " + node.range.source.internalPath);
-          schema.deps.push(depSearch);
-          continue;
-        }
-        const internalSearch = getClass(unknownType, node.range.source);
-        if (internalSearch) {
-          if (DEBUG > 0) console.log("Found " + unknownType + " internally from " + node.range.source.internalPath);
-          this.visitClassDeclaration(internalSearch);
-          this.schemas.get(node.range.source.internalPath).push(this.schema);
-          schema.deps.push(this.schema);
-          this.schema = schema;
+          if (DEBUG > 0) console.log("Found " + unknownType + " in dependencies of " + source.internalPath);
+          if (!schema.deps.some(v => v.name == depSearch.name)) schema.deps.push(depSearch);
         } else {
-          const externalSearch = getImportedClass(unknownType, node.range.source, this.parser);
-          if (externalSearch) {
-            if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + node.range.source.internalPath);
-            this.visitClassDeclaration(externalSearch);
-            this.schemas.get(node.range.source.internalPath).push(this.schema);
-            schema.deps.push(this.schema);
-            this.schema = schema;
+          const internalSearch = getClass(unknownType, source);
+          if (internalSearch) {
+            if (DEBUG > 0) console.log("Found " + unknownType + " internally from " + source.internalPath);
+            if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+              this.visitClassDeclarationRef(internalSearch);
+              this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
+              this.visitClassDeclaration(node);
+              return;
+            }
+            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find(s => s.name == internalSearch.name.text);
+            if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
+            schema.deps.push(schem);
+          } else {
+            const externalSearch = getImportedClass(unknownType, source, this.parser);
+            if (externalSearch) {
+              if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
+              if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+                this.visitClassDeclarationRef(externalSearch);
+                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                this.visitClassDeclaration(node);
+                return;
+              }
+              const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find(s => s.name == externalSearch.name.text);
+              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+              schema.deps.push(schem);
+            }
           }
         }
       }
     }
 
-    this.schemas.get(node.range.source.internalPath).push(schema);
+    this.schemas.get(source.internalPath).push(schema);
     this.schema = schema;
-    this.visitedClasses.add(node.range.source.internalPath + node.name.text);
+    this.visitedClasses.add(source.internalPath + node.name.text);
 
     let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
     let INITIALIZE = "@inline __INITIALIZE(): this {\n";
@@ -195,7 +201,7 @@ class JSONTransform extends Visitor {
     let DESERIALIZE_CUSTOM = "";
     let SERIALIZE_CUSTOM = "";
 
-    if (DEBUG > 0) console.log("Created schema: " + this.schema.name + " in file " + node.range.source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n  " + this.schema.deps.map((v) => v.name).join("\n  ") : ""));
+    if (DEBUG > 0) console.log("Created schema: " + this.schema.name + " in file " + source.normalizedPath + (this.schema.deps.length ? " with dependencies:\n  " + this.schema.deps.map((v) => v.name).join("\n  ") : ""));
 
     if (serializers.length > 1) throwError("Multiple serializers detected for class " + node.name.text + " but schemas can only have one serializer!", serializers[1].range);
     if (deserializers.length > 1) throwError("Multiple deserializers detected for class " + node.name.text + " but schemas can only have one deserializer!", deserializers[1].range);
@@ -248,7 +254,9 @@ class JSONTransform extends Visitor {
 
     for (const member of members) {
       if (!member.type) throwError("Fields must be strongly typed", node.range);
-      const type = toString(member.type!);
+      let type = toString(member.type!);
+      type = this.src.aliases.find(v => stripNull(v.name) == stripNull(type))?.getBaseType() || type;
+
       const name = member.name;
       const value = member.initializer ? toString(member.initializer!) : null;
 
@@ -418,16 +426,27 @@ class JSONTransform extends Visitor {
     };
 
     for (const member of this.schema.members) {
-      if (member.type.endsWith(" | null")) sortedMembers.null.push(member);
-      if (isString(member.type) || member.type == "JSON.Raw") sortedMembers.string.push(member);
-      else if (isBoolean(member.type) || member.type.startsWith("JSON.Box<bool")) sortedMembers.boolean.push(member);
-      else if (isPrimitive(member.type) || member.type.startsWith("JSON.Box<")) sortedMembers.number.push(member);
-      else if (isArray(member.type)) sortedMembers.array.push(member);
-      else sortedMembers.object.push(member);
+      const type = stripNull(member.type);
+      if (node.isGeneric && node.typeParameters.some((p) => stripNull(p.name.text) == type)) {
+        member.generic = true;
+        sortedMembers.string.push(member);
+        sortedMembers.number.push(member);
+        sortedMembers.object.push(member);
+        sortedMembers.array.push(member);
+        sortedMembers.boolean.push(member);
+        sortedMembers.null.push(member);
+      } else {
+        if (member.node.type.isNullable) sortedMembers.null.push(member);
+        if (isString(type) || type == "JSON.Raw") sortedMembers.string.push(member);
+        else if (isBoolean(type) || type.startsWith("JSON.Box<bool")) sortedMembers.boolean.push(member);
+        else if (isPrimitive(type) || type.startsWith("JSON.Box<")) sortedMembers.number.push(member);
+        else if (isArray(type)) sortedMembers.array.push(member);
+        else if (isStruct(type, source)) sortedMembers.object.push(member);
+        else throw new Error("Could not determine type " + type + " for member " + member.name + " in class " + this.schema.name);
+      }
     }
 
     indent = "";
-    let shouldGroup = false;
 
     DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
     DESERIALIZE += indent + "  let keyEnd: usize = 0;\n";
@@ -599,22 +618,22 @@ class JSONTransform extends Visitor {
       DESERIALIZE += "          while (srcStart < srcEnd) {\n";
       DESERIALIZE += "            const code = load<u16>(srcStart);\n";
       DESERIALIZE += "            if (code == 34 && load<u16>(srcStart - 2) !== 92) {\n";
-      if (DEBUG > 1)DESERIALIZE += "              console.log(\"Value (string, " + (++id) + "): \" + JSON.Util.ptrToStr(lastIndex, srcStart + 2));";
+      if (DEBUG > 1) DESERIALIZE += "              console.log(\"Value (string, " + (++id) + "): \" + JSON.Util.ptrToStr(lastIndex, srcStart + 2));";
       generateGroups(sortedMembers.string, (group) => {
         generateConsts(group);
         const first = group[0];
         const fName = first.alias || first.name;
-        DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            if (" + (first.generic ? "isString<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
         DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
         DESERIALIZE += indent + "              srcStart += 4;\n";
         DESERIALIZE += indent + "              keyStart = 0;\n";
         DESERIALIZE += indent + "              break;\n";
         DESERIALIZE += indent + "            }";
 
-        for (let i = 1; i <group.length; i++) {
+        for (let i = 1; i < group.length; i++) {
           const mem = group[i];
           const memName = mem.alias || mem.name;
-          DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isString<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
           DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart + 2), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "              srcStart += 4;\n";
           DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -655,7 +674,7 @@ class JSONTransform extends Visitor {
         generateConsts(group);
         const first = group[0];
         const fName = first.alias || first.name;
-        DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            if (" + (first.generic ? "(isInteger<" + first.type + ">() || isFloat<" + first.type + ">()) && " : "") + getComparision(fName) + ") { // " + fName + "\n";
         DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
         DESERIALIZE += indent + "              srcStart += 2;\n";
         DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -665,7 +684,7 @@ class JSONTransform extends Visitor {
         for (let i = 1; i < group.length; i++) {
           const mem = group[i];
           const memName = mem.alias || mem.name;
-          DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "(isInteger<" + mem.type + ">() || isFloat<" + mem.type + ">()) && " : "") + getComparision(memName) + ") { // " + memName + "\n";
           DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "              srcStart += 2;\n";
           DESERIALIZE += indent + "              keyStart = 0;\n";
@@ -712,7 +731,7 @@ class JSONTransform extends Visitor {
         generateConsts(group);
         const first = group[0];
         const fName = first.alias || first.name;
-        DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            if (" + (first.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(fName) + ") { // " + fName + "\n";
         DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
         DESERIALIZE += indent + "              keyStart = 0;\n";
         DESERIALIZE += indent + "              break;\n";
@@ -721,7 +740,7 @@ class JSONTransform extends Visitor {
         for (let i = 1; i < group.length; i++) {
           const mem = group[i];
           const memName = mem.alias || mem.name;
-          DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparision(memName) + ") { // " + memName + "\n";
           DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "              keyStart = 0;\n";
           DESERIALIZE += indent + "              break;\n";
@@ -768,7 +787,7 @@ class JSONTransform extends Visitor {
         generateConsts(group);
         const first = group[0];
         const fName = first.alias || first.name;
-        DESERIALIZE += indent + "            if (" + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            if (" + (first.generic ? "isArray<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
         DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
         DESERIALIZE += indent + "              keyStart = 0;\n";
         DESERIALIZE += indent + "              break;\n";
@@ -777,7 +796,7 @@ class JSONTransform extends Visitor {
         for (let i = 1; i < group.length; i++) {
           const mem = group[i];
           const memName = mem.alias || mem.name;
-          DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isArray" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
           DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "              keyStart = 0;\n";
           DESERIALIZE += indent + "              break;\n";
@@ -813,39 +832,39 @@ class JSONTransform extends Visitor {
       DESERIALIZE += "          srcStart += 8;\n";
       if (DEBUG > 1) DESERIALIZE += "              console.log(\"Value (bool, " + (++id) + "): \" + JSON.Util.ptrToStr(lastIndex, srcStart - 8));";
       generateGroups(sortedMembers.boolean, (group) => {
-          generateConsts(group);
+        generateConsts(group);
         const first = group[0];
-          const fName =first.alias || first.name;
-          DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
-          DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        const fName = first.alias || first.name;
+        DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
+
+        for (let i = 1; i < group.length; i++) {
+          const mem = group[i];
+          const memName = mem.alias || mem.name;
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "            srcStart += 2;\n";
           DESERIALIZE += indent + "            keyStart = 0;\n";
           DESERIALIZE += indent + "            break;\n";
           DESERIALIZE += indent + "          }";
+        }
 
-          for (let i = 1; i < group.length; i++) {
-            const mem = group[i];
-            const memName = mem.alias || mem.name;
-            DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
-            DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
-            DESERIALIZE += indent + "            srcStart += 2;\n";
-            DESERIALIZE += indent + "            keyStart = 0;\n";
-            DESERIALIZE += indent + "            break;\n";
-            DESERIALIZE += indent + "          }";
-          }
-
-          if (STRICT) {
-            DESERIALIZE += " else {\n";
-            DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
-            DESERIALIZE += indent + "          }\n";
-          } else {
-            DESERIALIZE += " else { \n";
-            DESERIALIZE += indent + "              srcStart += 2;\n";
-            DESERIALIZE += indent + "              keyStart = 0;\n";
-            DESERIALIZE += indent + "              break;\n";
-            DESERIALIZE += indent + "            }\n";
-          }
-        },
+        if (STRICT) {
+          DESERIALIZE += " else {\n";
+          DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
+          DESERIALIZE += indent + "          }\n";
+        } else {
+          DESERIALIZE += " else { \n";
+          DESERIALIZE += indent + "              srcStart += 2;\n";
+          DESERIALIZE += indent + "              keyStart = 0;\n";
+          DESERIALIZE += indent + "              break;\n";
+          DESERIALIZE += indent + "            }\n";
+        }
+      },
         "boolean",
       );
 
@@ -863,41 +882,41 @@ class JSONTransform extends Visitor {
       DESERIALIZE += "        if (load<u64>(srcStart, 2) == 28429466576093281) {\n";
       DESERIALIZE += "          srcStart += 10;\n";
       if (DEBUG > 1) DESERIALIZE += "              console.log(\"Value (bool, " + (++id) + "): \" + JSON.Util.ptrToStr(lastIndex, srcStart - 10));";
-      generateGroups( sortedMembers.boolean, (group) => {
-          generateConsts(group);
+      generateGroups(sortedMembers.boolean, (group) => {
+        generateConsts(group);
 
-          const first = group[0];
-          const fName = first.alias || first.name;
-          DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
-          DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        const first = group[0];
+        const fName = first.alias || first.name;
+        DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
+
+        for (let i = 1; i < group.length; i++) {
+          const mem = group[i];
+          const memName = mem.alias || mem.name;
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "            srcStart += 2;\n";
           DESERIALIZE += indent + "            keyStart = 0;\n";
           DESERIALIZE += indent + "            break;\n";
           DESERIALIZE += indent + "          }";
+        }
 
-          for (let i = 1; i < group.length; i++) {
-            const mem = group[i];
-            const memName = mem.alias || mem.name;
-            DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
-            DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
-            DESERIALIZE += indent + "            srcStart += 2;\n";
-            DESERIALIZE += indent + "            keyStart = 0;\n";
-            DESERIALIZE += indent + "            break;\n";
-            DESERIALIZE += indent + "          }";
-          }
-
-          if (STRICT) {
-            DESERIALIZE += " else {\n";
-            DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
-            DESERIALIZE += indent + "          }\n";
-          } else {
-            DESERIALIZE += " else { \n";
-            DESERIALIZE += indent + "              srcStart += 2;\n";
-            DESERIALIZE += indent + "              keyStart = 0;\n";
-            DESERIALIZE += indent + "              break;\n";
-            DESERIALIZE += indent + "            }\n";
-          }
-        },
+        if (STRICT) {
+          DESERIALIZE += " else {\n";
+          DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
+          DESERIALIZE += indent + "          }\n";
+        } else {
+          DESERIALIZE += " else { \n";
+          DESERIALIZE += indent + "              srcStart += 2;\n";
+          DESERIALIZE += indent + "              keyStart = 0;\n";
+          DESERIALIZE += indent + "              break;\n";
+          DESERIALIZE += indent + "            }\n";
+        }
+      },
         "boolean",
       );
 
@@ -920,37 +939,37 @@ class JSONTransform extends Visitor {
         generateConsts(group);
 
         const first = group[0];
-          const fName = first.alias || first.name;
-          DESERIALIZE += indent + "          if (" + getComparision(fName) + ") { // " + fName + "\n";
-          DESERIALIZE += indent + "            store<" + first.type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        const fName = first.alias || first.name;
+        DESERIALIZE += indent + "          if (" + (first.generic ? "isNullable<" + first.type + ">() && " : "") + getComparision(fName) + ") { // " + fName + "\n";
+        DESERIALIZE += indent + "            store<usize>(changetype<usize>(out), 0, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+        DESERIALIZE += indent + "            srcStart += 2;\n";
+        DESERIALIZE += indent + "            keyStart = 0;\n";
+        DESERIALIZE += indent + "            break;\n";
+        DESERIALIZE += indent + "          }";
+
+        for (let i = 1; i < group.length; i++) {
+          const mem = group[i];
+          const memName = mem.alias || mem.name;
+          DESERIALIZE += indent + " else if (" + (mem.generic ? "isNullable<" + mem.type + ">() && " : "") + getComparision(memName) + ") { // " + memName + "\n";
+          DESERIALIZE += indent + "            store<usize>(changetype<usize>(out), 0, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
           DESERIALIZE += indent + "            srcStart += 2;\n";
           DESERIALIZE += indent + "            keyStart = 0;\n";
           DESERIALIZE += indent + "            break;\n";
           DESERIALIZE += indent + "          }";
+        }
 
-          for (let i = 1; i < group.length; i++) {
-            const mem = group[i];
-            const memName = mem.alias || mem.name;
-            DESERIALIZE += indent + " else if (" + getComparision(memName) + ") { // " + memName + "\n";
-            DESERIALIZE += indent + "            store<" + mem.type + ">(changetype<usize>(out), null, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
-            DESERIALIZE += indent + "            srcStart += 2;\n";
-            DESERIALIZE += indent + "            keyStart = 0;\n";
-            DESERIALIZE += indent + "            break;\n";
-            DESERIALIZE += indent + "          }";
-          }
-
-          if (STRICT) {
-            DESERIALIZE += " else {\n";
-            DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
-            DESERIALIZE += indent + "          }\n";
-          } else {
-            DESERIALIZE += " else { \n";
-            DESERIALIZE += indent + "              srcStart += 2;\n";
-            DESERIALIZE += indent + "              keyStart = 0;\n";
-            DESERIALIZE += indent + "              break;\n";
-            DESERIALIZE += indent + "            }\n";
-          }
-        },
+        if (STRICT) {
+          DESERIALIZE += " else {\n";
+          DESERIALIZE += indent + '            throw new Error("Unexpected key value pair in JSON object \'" + JSON.Util.ptrToStr(keyStart, keyEnd) + ":" + JSON.Util.ptrToStr(lastIndex, srcStart) + "\' at position " + (srcEnd - srcStart).toString());\n';
+          DESERIALIZE += indent + "          }\n";
+        } else {
+          DESERIALIZE += " else { \n";
+          DESERIALIZE += indent + "              srcStart += 2;\n";
+          DESERIALIZE += indent + "              keyStart = 0;\n";
+          DESERIALIZE += indent + "              break;\n";
+          DESERIALIZE += indent + "            }\n";
+        }
+      },
         "null",
       );
 
@@ -1074,7 +1093,7 @@ class JSONTransform extends Visitor {
       )
         ? path.join(pkgPath, fromPath.slice(5))
         : fromPath
-      : path.join(baseDir, fromPath);
+      : path.join(this.baseCWD, fromPath);
 
     const bsImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "bs" || d.name.text == "bs"));
     const jsonImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "JSON" || d.name.text == "JSON"));
@@ -1237,10 +1256,6 @@ export default class Transformer extends Transform {
       transformer.currentSource = source;
       transformer.visit(source);
 
-      if (transformer.topStatements.length) {
-        source.statements.unshift(...transformer.topStatements);
-        transformer.topStatements = [];
-      }
       if (transformer.simdStatements.length) {
         for (const simd of transformer.simdStatements) source.statements.unshift(SimpleParser.parseTopLevelStatement(simd));
       }