json-as 1.1.6 → 1.1.8

package/transform/src/index.ts

@@ -1,7 +1,7 @@
-import { ClassDeclaration, FieldDeclaration, IdentifierExpression, Parser, Source, NodeKind, CommonFlags, ImportStatement, Node, Tokenizer, SourceKind, NamedTypeNode, Range, FEATURE_SIMD, FunctionExpression, MethodDeclaration, Statement, Program, Feature } from "assemblyscript/dist/assemblyscript.js";
+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 { Transform } from "assemblyscript/dist/transform.js";
 import { Visitor } from "./visitor.js";
-import { isStdlib, SimpleParser, toString } from "./util.js";
+import { cloneNode, isStdlib, replaceRef, SimpleParser, toString } from "./util.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import { Property, PropertyFlags, Schema } from "./types.js";
@@ -12,6 +12,42 @@ let indent = "  ";
 const DEBUG = process.env["JSON_DEBUG"];
 const STRICT = !(process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "false");
 
+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();
 
@@ -61,6 +97,10 @@ class JSONTransform extends Visitor {
     if (serializers.length) {
       this.schema.custom = true;
       const serializer = serializers[0];
+      const hasCall = CustomTransform.hasCall(serializer);
+      
+      CustomTransform.visit(serializer);
+
       // if (!serializer.signature.parameters.length) throwError("Could not find any parameters in custom serializer for " + this.schema.name + ". Serializers must have one parameter like 'serializer(self: " + this.schema.name + "): string {}'", serializer.range);
       if (serializer.signature.parameters.length > 1) throwError("Found too many parameters in custom serializer for " + this.schema.name + ", but serializers can only accept one parameter of type '" + this.schema.name + "'!", serializer.signature.parameters[1].range);
       if (serializer.signature.parameters.length > 0 && (<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != node.name.text && (<NamedTypeNode>serializer.signature.parameters[0].type).name.identifier.text != "this") throwError("Type of parameter for custom serializer does not match! It should be 'string'either be 'this' or '" + this.schema.name + "'", serializer.signature.parameters[0].type.range);
@@ -71,6 +111,7 @@ class JSONTransform extends Visitor {
       }
       SERIALIZE_CUSTOM += "  __SERIALIZE(ptr: usize): void {\n";
       SERIALIZE_CUSTOM += "    const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
+      if (hasCall) SERIALIZE_CUSTOM += "    bs.resetState();\n";
       SERIALIZE_CUSTOM += "    const dataSize = data.length << 1;\n";
       SERIALIZE_CUSTOM += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
       SERIALIZE_CUSTOM += "    bs.offset += dataSize;\n";
@@ -199,13 +240,18 @@ class JSONTransform extends Visitor {
     }
 
     for (const member of this.schema.members) {
-      const nonNullType = member.type.replace(" | null", "");
-      if (!isPrimitive(nonNullType)) {
-        const schema = this.schemas.find((v) => v.name == nonNullType);
-        if (schema && !this.schema.deps.includes(schema)) {
+      if (isStruct(member.type)) {
+        const schema = this.schemas.find((v) => v.name == stripNull(member.type));
+        if (!schema) continue;
+
+        if (!this.schema.deps.includes(schema)) {
           this.schema.deps.push(schema);
           this.schema.byteSize += schema.byteSize;
         }
+
+        // if (schema.custom) {
+        //   member.flags.set(PropertyFlags.Custom, null);
+        // }
       }
     }
 
@@ -360,6 +406,11 @@ class JSONTransform extends Visitor {
     // if (shouldGroup) DESERIALIZE += "    const keySize = keyEnd - keyStart;\n";
 
     const groupMembers = (members: Property[]): Property[][] => {
+      // const customMembers = this.schema.members.filter((m) => m.flags.has(PropertyFlags.Custom));
+      // console.log("Custom members: ", customMembers.map((m) => m.name));
+
+      // members.push(...customMembers)
+
       const groups = new Map<number, Property[]>();
 
       for (const member of members) {
@@ -384,7 +435,44 @@ class JSONTransform extends Visitor {
         .sort((a, b) => b.length - a.length);
     };
 
-    const generateGroups = (members: Property[], cb: (group: Property[]) => void) => {
+    // const groupMembers = (members: Property[]): Property[][] => {
+    //   const customMembers = this.schema.members.filter((m) =>
+    //     m.flags.has(PropertyFlags.Custom)
+    //   );
+    //   console.log("Custom members: ", customMembers.map((m) => m.name));
+
+    //   const customSet = new Set(customMembers);
+    //   members = members.filter((m) => !customSet.has(m));
+    //   members.push(...customMembers);
+
+    //   const groups = new Map<number, Property[]>();
+
+    //   for (const member of members) {
+    //     const name = member.alias || member.name;
+    //     const length = name.length;
+
+    //     if (!groups.has(length)) {
+    //       groups.set(length, []);
+    //     }
+
+    //     groups.get(length)!.push(member);
+    //   }
+
+    //   return [...groups.entries()]
+    //     .sort(([a], [b]) => a - b)
+    //     .map(([_, group]) => {
+    //       const regulars = group.filter((m) => !customSet.has(m));
+    //       const customs = group.filter((m) => customSet.has(m));
+
+    //       const sortByLength = (a: Property, b: Property) =>
+    //         (a.alias || a.name).length - (b.alias || b.name).length;
+
+    //       return [...regulars.sort(sortByLength), ...customs.sort(sortByLength)];
+    //     });
+    // };
+
+
+    const generateGroups = (members: Property[], cb: (group: Property[]) => void, nil: boolean = false) => {
       const groups = groupMembers(members);
       DESERIALIZE += "     switch (<u32>keyEnd - <u32>keyStart) {\n";
 
@@ -396,7 +484,7 @@ class JSONTransform extends Visitor {
       }
 
       DESERIALIZE += "    }\n";
-      if (!(members[0].node.type.isNullable || isBoolean(members[0].type)))DESERIALIZE += "  break;\n";
+      if (!members[0].node.type.isNullable && !isBoolean(members[0].type)) DESERIALIZE += "  break;\n";
     }
 
     const generateComparisions = (members: Property[]) => {
@@ -677,7 +765,7 @@ class JSONTransform extends Visitor {
           DESERIALIZE += indent + '            throw new Error("Unexpected key in JSON object \'" + String.fromCharCode(load<u16>(srcStart)) + "\' at position " + (srcEnd - srcStart).toString());\n';
           DESERIALIZE += indent + "          }\n";
         }
-      });
+      }, true);
 
       DESERIALIZE += "        }"; // Close first char check
       DESERIALIZE += "\n      }"; // Close first char check
@@ -1100,4 +1188,4 @@ function getComparision(data: string) {
       return toMemCCheck(data);
     }
   }
-}
+}

package/transform/src/types.ts

@@ -4,6 +4,7 @@ export enum PropertyFlags {
   OmitNull,
   OmitIf,
   Raw,
+  Custom
 }
 
 export class Property {

package/transform/src/util.ts

@@ -1,5 +1,5 @@
 // Taken from https://github.com/as-pect/visitor-as/blob/master/src/simpleParser.ts
-import { Parser, Tokenizer, Source, SourceKind, Expression, Statement, NamespaceDeclaration, ClassDeclaration, DeclarationStatement, Range, Node } from "assemblyscript/dist/assemblyscript.js";
+import { Parser, Tokenizer, Source, SourceKind, Expression, Statement, NamespaceDeclaration, ClassDeclaration, DeclarationStatement, Range, Node, NodeKind } from "assemblyscript/dist/assemblyscript.js";
 import { ASTBuilder } from "./builder.js";
 
 export class SimpleParser {
@@ -54,3 +54,80 @@ export function isStdlib(s: Source | { range: Range }): boolean {
 export function toString(node: Node): string {
   return ASTBuilder.build(node);
 }
+
+export function replaceRef(
+  node: Node,
+  replacement: Node | Node[],
+  ref: Node | Node[] | null,
+): void {
+  if (!node || !ref) return;
+  const nodeExpr = stripExpr(node);
+
+  if (Array.isArray(ref)) {
+    for (let i = 0; i < ref.length; i++) {
+      if (stripExpr(ref[i]) === nodeExpr) {
+        if (Array.isArray(replacement)) ref.splice(i, 1, ...replacement);
+        else ref.splice(i, 1, replacement);
+        return; // Exit early after replacement
+      }
+    }
+  } else if (typeof ref === "object") {
+    for (const key of Object.keys(ref)) {
+      const current = ref[key] as Node | Node[];
+      if (Array.isArray(current)) {
+        for (let i = 0; i < current.length; i++) {
+          if (stripExpr(current[i]) === nodeExpr) {
+            if (Array.isArray(replacement))
+              current.splice(i, 1, ...replacement);
+            else current.splice(i, 1, replacement);
+            return;
+          }
+        }
+      } else if (stripExpr(current) === nodeExpr) {
+        ref[key] = replacement;
+        return;
+      }
+    }
+  }
+}
+
+export function cloneNode(
+  input: Node | Node[] | null,
+  seen = new WeakMap(),
+  path = "",
+): Node | Node[] | null {
+  if (input === null || typeof input !== "object") return input;
+
+  if (Array.isArray(input)) {
+    return input.map((item, index) =>
+      cloneNode(item, seen, `${path}[${index}]`),
+    ) as Node | Node[] | null;
+  }
+
+  if (seen.has(input)) return seen.get(input);
+
+  const prototype = Object.getPrototypeOf(input);
+  const clone = Array.isArray(input) ? [] : Object.create(prototype);
+  seen.set(input, clone);
+
+  for (const key of Reflect.ownKeys(input)) {
+    const value = input[key];
+    const newPath = path ? `${path}.${String(key)}` : String(key);
+
+    if (newPath.endsWith(".source")) {
+      clone[key] = value;
+    } else if (value && typeof value === "object") {
+      clone[key] = cloneNode(value, seen, newPath);
+    } else {
+      clone[key] = value;
+    }
+  }
+
+  return clone as Node | Node[] | null;
+}
+
+export function stripExpr(node: Node): Node {
+  if (!node) return node;
+  if (node.kind == NodeKind.Expression) return node["expression"];
+  return node;
+}