json-as 1.3.0 → 1.3.1

package/transform/lib/index.js

@@ -19,10 +19,63 @@ function needsReferenceLoad(type) {
 }
 function getSerializeCall(type, realName) {
     if (type == "ArrayBuffer") {
-        return `JSON.__serializeArrayBuffer(load<ArrayBuffer>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+        return `JSON.__serialize<ArrayBuffer>(load<ArrayBuffer>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
     }
     return needsReferenceLoad(type) ? `JSON.__serialize<${type}>(changetype<${type}>(load<usize>(ptr, offsetof<this>(${JSON.stringify(realName)}))));\n` : `JSON.__serialize<${type}>(load<${type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
 }
+const CUSTOM_JSON_KINDS = new Set(["any", "string", "number", "object", "array", "boolean", "null", "any | null", "string | null", "number | null", "object | null", "array | null", "boolean | null"]);
+function parseCustomJsonKind(method, decoratorName) {
+    const decorator = method.decorators?.find((v) => v.name.text.toLowerCase() == decoratorName);
+    if (!decorator || !decorator.args || decorator.args.length == 0)
+        return "any";
+    if (decorator.args.length > 1)
+        throwError(`@${decoratorName} accepts at most one argument`, decorator.range);
+    const arg = decorator.args[0];
+    if (arg.kind != 16 || arg.literalKind != 2) {
+        throwError(`@${decoratorName} argument must be a string literal like @${decoratorName}("string")`, arg.range);
+    }
+    const kind = arg.value;
+    if (!CUSTOM_JSON_KINDS.has(kind)) {
+        throwError(`Unsupported @${decoratorName} JSON type '${kind}'. Expected one of: any, string, number, object, array, boolean, null`, arg.range);
+    }
+    return kind;
+}
+function addMemberToCustomBucket(sortedMembers, member, kind) {
+    const isNullable = kind.endsWith(" | null");
+    const baseKind = isNullable ? kind.slice(0, kind.length - 7) : kind;
+    if (isNullable)
+        sortedMembers.null.push(member);
+    switch (baseKind) {
+        case "string":
+            sortedMembers.string.push(member);
+            break;
+        case "number":
+            sortedMembers.number.push(member);
+            break;
+        case "boolean":
+            sortedMembers.boolean.push(member);
+            break;
+        case "null":
+            if (!isNullable)
+                sortedMembers.null.push(member);
+            break;
+        case "array":
+            sortedMembers.array.push(member);
+            break;
+        case "object":
+            sortedMembers.object.push(member);
+            break;
+        default:
+            sortedMembers.string.push(member);
+            sortedMembers.number.push(member);
+            sortedMembers.object.push(member);
+            sortedMembers.array.push(member);
+            sortedMembers.boolean.push(member);
+            if (!isNullable)
+                sortedMembers.null.push(member);
+            break;
+    }
+}
 export class JSONTransform extends Visitor {
     static SN = new JSONTransform();
     program;
@@ -34,6 +87,46 @@ export class JSONTransform extends Visitor {
     imports = [];
     simdStatements = [];
     visitedClasses = new Set();
+    collectInheritedFieldMembers(node, source, members, visited = new Set()) {
+        if (!node.extendsType)
+            return;
+        const extendsName = source.resolveExtendsName(node);
+        if (!extendsName || visited.has(extendsName))
+            return;
+        visited.add(extendsName);
+        let baseDecl = source.getClass(extendsName);
+        let baseSource = baseDecl ? source : null;
+        if (!baseDecl) {
+            const imported = source.getImportedClass(extendsName, this.parser);
+            if (imported) {
+                baseDecl = imported;
+                baseSource = this.sources.get(imported.range.source);
+            }
+        }
+        if (!baseDecl) {
+            const available = source.getAvailableClass(extendsName, this.parser);
+            if (available) {
+                baseDecl = available;
+                baseSource = this.sources.get(available.range.source);
+            }
+        }
+        if (!baseDecl || !baseSource)
+            return;
+        const isDecoratedBase = !!baseDecl.decorators?.some((decorator) => {
+            const name = decorator.name.text;
+            return name === "json" || name === "serializable";
+        });
+        if (isDecoratedBase)
+            return;
+        this.collectInheritedFieldMembers(baseDecl, baseSource, members, visited);
+        const inheritedMembers = baseDecl.members.filter((v) => v.kind === 54 && !v.is(32) && !v.is(512) && !v.is(1024) && !v.decorators?.some((decorator) => decorator.name.text === "omit"));
+        for (let i = inheritedMembers.length - 1; i >= 0; i--) {
+            const inherited = inheritedMembers[i];
+            if (!members.some((member) => member.name.text == inherited.name.text)) {
+                members.unshift(inherited);
+            }
+        }
+    }
     visitClassDeclarationRef(node) {
         if (!node.decorators?.length ||
             !node.decorators.some((decorator) => {
@@ -88,13 +181,14 @@ export class JSONTransform extends Visitor {
             return;
         if (!this.schemas.has(source.internalPath))
             this.schemas.set(source.internalPath, []);
-        const members = [...node.members.filter((v) => v.kind === 54 && v.flags !== 32 && v.flags !== 512 && v.flags !== 1024 && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
+        const members = [...node.members.filter((v) => v.kind === 54 && !v.is(32) && !v.is(512) && !v.is(1024) && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
         const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer") && !v.name.text.startsWith("__try"))];
         const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer") && !v.name.text.startsWith("__try"))];
         const schema = new Schema();
         schema.node = node;
         schema.name = source.getQualifiedName(node);
         if (node.extendsType) {
+            this.collectInheritedFieldMembers(node, source, members);
             const extendsName = source.resolveExtendsName(node);
             if (!schema.parent) {
                 const depSearch = schema.deps.find((v) => v.name == extendsName);
@@ -140,6 +234,30 @@ export class JSONTransform extends Visitor {
                             schema.deps.push(schem);
                             schema.parent = schem;
                         }
+                        else {
+                            const availableSearch = source.getAvailableClass(extendsName, this.parser);
+                            if (availableSearch) {
+                                if (DEBUG > 0)
+                                    console.log("Found " + availableSearch.name.text + " from available sources for " + source.internalPath);
+                                const availableSource = this.sources.get(availableSearch.range.source);
+                                if (availableSearch.decorators?.some((decorator) => {
+                                    const name = decorator.name.text;
+                                    return name === "json" || name === "serializable";
+                                })) {
+                                    if (!this.visitedClasses.has(availableSource.getFullPath(availableSearch))) {
+                                        this.visitClassDeclarationRef(availableSearch);
+                                        this.schemas.get(availableSource.internalPath).push(this.schema);
+                                        this.visitClassDeclaration(node);
+                                        return;
+                                    }
+                                    const schem = this.schemas.get(availableSource.internalPath)?.find((s) => s.name == extendsName);
+                                    if (schem) {
+                                        schema.deps.push(schem);
+                                        schema.parent = schem;
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -256,7 +374,9 @@ export class JSONTransform extends Visitor {
         if (serializers.length) {
             this.schema.custom = true;
             const serializer = serializers[0];
+            const serializerJsonKind = parseCustomJsonKind(serializer, "serializer");
             const hasCall = CustomTransform.hasCall(serializer);
+            this.schema.customJsonKind = serializerJsonKind;
             CustomTransform.visit(serializer);
             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);
@@ -268,9 +388,16 @@ export class JSONTransform extends Visitor {
                 serializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", serializer.range), null, serializer.range));
             }
             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";
+            if (hasCall) {
+                SERIALIZE_CUSTOM += "    const savedOffset = bs.offset;\n";
+                SERIALIZE_CUSTOM += "    const savedStackSize = bs.stackSize;\n";
+            }
+            SERIALIZE_CUSTOM += "    const self = changetype<this>(ptr);\n";
+            SERIALIZE_CUSTOM += "    const data = self." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "self" : "") + ");\n";
+            if (hasCall) {
+                SERIALIZE_CUSTOM += "    bs.offset = savedOffset;\n";
+                SERIALIZE_CUSTOM += "    bs.stackSize = savedStackSize;\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";
@@ -279,6 +406,12 @@ export class JSONTransform extends Visitor {
         if (deserializers.length) {
             this.schema.custom = true;
             const deserializer = deserializers[0];
+            const deserializerJsonKind = parseCustomJsonKind(deserializer, "deserializer");
+            if (this.schema.customJsonKind != "any" && deserializerJsonKind != "any" && this.schema.customJsonKind != deserializerJsonKind) {
+                throwError(`@serializer and @deserializer JSON types for ${this.schema.name} must match`, deserializer.range);
+            }
+            if (this.schema.customJsonKind == "any")
+                this.schema.customJsonKind = deserializerJsonKind;
             if (!deserializer.signature.parameters.length)
                 throwError("Could not find any parameters in custom deserializer for " + this.schema.name + ". Deserializers must have one parameter like 'deserializer(data: string): " + this.schema.name + " {}'", deserializer.range);
             if (deserializer.signature.parameters.length > 1)
@@ -290,10 +423,8 @@ export class JSONTransform extends Visitor {
             if (!deserializer.decorators.some((v) => v.name.text == "inline")) {
                 deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
             }
-            DESERIALIZE_CUSTOM += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
-            DESERIALIZE_CUSTOM += "    const data = inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
-            DESERIALIZE_CUSTOM += "    memory.copy(changetype<usize>(out), changetype<usize>(data), offsetof<nonnull<__JSON_T>>());\n";
-            DESERIALIZE_CUSTOM += "    return srcEnd;\n";
+            DESERIALIZE_CUSTOM += "  @inline __DESERIALIZE_CUSTOM(data: string): this {\n";
+            DESERIALIZE_CUSTOM += "    return inline.always(this." + deserializer.name.text + "(data));\n";
             DESERIALIZE_CUSTOM += "  }\n";
         }
         if (!members.length && !deserializers.length && !serializers.length) {
@@ -316,6 +447,7 @@ export class JSONTransform extends Visitor {
             mem.value = value;
             mem.node = member;
             mem.byteSize = sizeof(mem.type);
+            mem.custom = schema.deps.some((dep) => dep?.name == stripNull(type) && dep.custom);
             this.schema.byteSize += mem.byteSize;
             if (member.decorators) {
                 for (const decorator of member.decorators) {
@@ -482,13 +614,12 @@ export class JSONTransform extends Visitor {
         };
         for (const member of this.schema.members) {
             const type = stripNull(member.type);
-            if (member.custom || member.generic) {
-                sortedMembers.string.push(member);
-                sortedMembers.number.push(member);
-                sortedMembers.object.push(member);
-                sortedMembers.array.push(member);
-                sortedMembers.boolean.push(member);
-                sortedMembers.null.push(member);
+            const customDep = this.schema.deps.find((dep) => dep && (dep.name == type || dep.name.endsWith("." + type)) && dep.custom);
+            const isCustomType = member.custom || !!customDep;
+            if (isCustomType || member.generic) {
+                addMemberToCustomBucket(sortedMembers, member, member.generic ? "any" : customDep?.customJsonKind || "any");
+                if (member.node.type.isNullable)
+                    sortedMembers.null.push(member);
             }
             else {
                 if (member.node.type.isNullable)
@@ -1222,13 +1353,16 @@ export class JSONTransform extends Visitor {
         const DESERIALIZE_DIRECT = useFastPath ? DESERIALIZE_FAST.replace("@inline __DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {", "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {") : DESERIALIZE.replace("__DESERIALIZE_SLOW<__JSON_T>", "__DESERIALIZE<__JSON_T>");
         const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE_CUSTOM || SERIALIZE, node);
         const INITIALIZE_METHOD = !useFastPath ? SimpleParser.parseClassMember(INITIALIZE, node) : null;
-        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_CUSTOM || DESERIALIZE_DIRECT, node);
+        const DESERIALIZE_CUSTOM_METHOD = DESERIALIZE_CUSTOM ? SimpleParser.parseClassMember(DESERIALIZE_CUSTOM, node) : null;
+        const DESERIALIZE_METHOD = DESERIALIZE_CUSTOM ? null : SimpleParser.parseClassMember(DESERIALIZE_DIRECT, node);
         const DESERIALIZE_FAST_METHOD = useFastPath ? SimpleParser.parseClassMember(DESERIALIZE_FAST, node) : null;
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_METHOD);
         if (!useFastPath && INITIALIZE_METHOD && !node.members.find((v) => v.name.text == "__INITIALIZE"))
             node.members.push(INITIALIZE_METHOD);
-        if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
+        if (DESERIALIZE_CUSTOM_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_CUSTOM"))
+            node.members.push(DESERIALIZE_CUSTOM_METHOD);
+        if (DESERIALIZE_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE"))
             node.members.push(DESERIALIZE_METHOD);
         if (!DESERIALIZE_CUSTOM && useFastPath && DESERIALIZE_FAST_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_FAST"))
             node.members.push(DESERIALIZE_FAST_METHOD);
@@ -1271,15 +1405,6 @@ export class JSONTransform extends Visitor {
         this.baseCWD = this.baseCWD.replaceAll("/", path.sep);
         const baseDir = path.resolve(fileURLToPath(import.meta.url), "..", "..", "..");
         let fromPath = node.range.source.normalizedPath.replaceAll("/", path.sep);
-        const isLib = path.dirname(baseDir).endsWith("node_modules");
-        if (!isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("assembly/index"))) {
-            const newPath = path.join(baseDir, "assembly", "index.ts");
-            this.parser.parseFile(readFileSync(newPath).toString(), newPath, false);
-        }
-        else if (isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("~lib/json-as/assembly/index"))) {
-            const newPath = "~lib/json-as/assembly/index.ts";
-            this.parser.parseFile(readFileSync(path.join(baseDir, "assembly", "index.ts")).toString(), newPath, false);
-        }
         fromPath = fromPath.startsWith("~lib") ? fromPath.slice(5) : 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"));
@@ -1456,11 +1581,7 @@ export default class Transformer extends Transform {
         }
     }
     afterParse(parser) {
-        const transformer = JSONTransform.SN;
-        transformer.schemas = new Map();
-        transformer.sources = new SourceSet();
-        transformer.visitedClasses = new Set();
-        transformer.simdStatements = [];
+        const transformer = new JSONTransform();
         const sources = parser.sources
             .filter((source) => {
             const p = source.internalPath;