json-as 0.9.8 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "JSON encoder/decoder for AssemblyScript",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",
@@ -15,12 +15,10 @@
   ],
   "license": "MIT",
   "scripts": {
-    "test": "npm run test:serialize && npm run test:deserialize",
-    "test:serialize": "wasmtime build/serialize.spec.wasm",
-    "test:deserialize": "wasmtime build/deserialize.spec.wasm",
-    "tests:build": "asc assembly/__tests__/serialize.spec.ts -o build/serialize.spec.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always & asc assembly/__tests__/deserialize.spec.ts -o build/deserialize.spec.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always",
-    "build:test": "JSON_DEBUG=true asc assembly/test.ts -o build/test.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 0 --shrinkLevel 0 --noAssert --uncheckedBehavior always",
-    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub",
+    "test": "wasmtime build/test.spec.wasm",
+    "pretest": "asc assembly/__tests__/test.spec.ts --target test",
+    "build:test": "JSON_DEBUG=true asc assembly/test.ts --target debug",
+    "build:bench": "asc bench/benchmark.ts -o bench/benchmark.wasm --transform ./transform --optimizeLevel 3 --shrinkLevel 0 --converge --noAssert --uncheckedBehavior always --runtime stub",
     "bench:wasmtime": "wasmtime ./bench/benchmark.wasm",
     "bench:wasmer": "wasmer --llvm ./bench/benchmark.wasm",
     "build:transform": "tsc -p ./transform",
@@ -33,20 +31,21 @@
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
     "as-bench": "^0.0.0-alpha",
-    "assemblyscript": "^0.27.27",
+    "as-console": "^7.0.0",
+    "assemblyscript": "^0.27.28",
     "assemblyscript-prettier": "^3.0.1",
     "benchmark": "^2.1.4",
+    "json-as": "link:json-as",
     "microtime": "^3.1.1",
     "prettier": "^3.3.2",
     "tinybench": "^2.8.0",
-    "typescript": "^5.4.5",
+    "typescript": "^5.5.3",
     "visitor-as": "^0.11.4"
   },
   "dependencies": {
-    "as-container": "^0.8.0",
+    "@hypercubed/as-mpz": "^2.2.0",
     "as-string-sink": "^0.5.3",
-    "as-test": "^0.0.3",
-    "as-variant": "^0.4.1",
+    "as-test": "^0.1.4",
     "as-virtual": "^0.2.0"
   },
   "overrides": {

package/transform/lib/index.js

@@ -150,6 +150,18 @@ class JSONTransform extends BaseVisitor {
             else if (mem.value) {
                 mem.initialize = "this." + name.text + " = " + mem.value;
             }
+            else if (t === "Map") {
+                mem.initialize = "this." + name.text + " = new " + mem.type + "()";
+            }
+            else if (t === "string") {
+                mem.initialize = "this." + name.text + " = \"\"";
+            }
+            else if (t === "Array") {
+                mem.initialize = "this." + name.text + " = instantiate<" + mem.type + ">()";
+            }
+            else {
+                console.log(t);
+            }
             schema.members.push(mem);
         }
         let SERIALIZE_RAW = "__SERIALIZE(): string {\n  let out = `{";

package/transform/lib/visitor.js

@@ -0,0 +1,516 @@
+import { ArrayLiteralExpression, AssertionExpression, BinaryExpression, CallExpression, ElementAccessExpression, FloatLiteralExpression, FunctionTypeNode, IdentifierExpression, NamedTypeNode, Node, ObjectLiteralExpression, Source, TypeParameterNode, BlockStatement, BreakStatement, ClassDeclaration, ClassExpression, CommaExpression, ContinueStatement, DecoratorNode, DoStatement, EmptyStatement, EnumDeclaration, EnumValueDeclaration, ExportDefaultStatement, ExportImportStatement, ExportMember, ExportStatement, ExpressionStatement, FieldDeclaration, ForStatement, FunctionDeclaration, FunctionExpression, IfStatement, ImportDeclaration, ImportStatement, IndexSignatureNode, InstanceOfExpression, IntegerLiteralExpression, InterfaceDeclaration, LiteralExpression, MethodDeclaration, NamespaceDeclaration, NewExpression, ParameterNode, ParenthesizedExpression, PropertyAccessExpression, RegexpLiteralExpression, ReturnStatement, StringLiteralExpression, SwitchCase, SwitchStatement, TemplateLiteralExpression, TernaryExpression, ThrowStatement, TryStatement, TypeDeclaration, TypeName, UnaryPostfixExpression, UnaryPrefixExpression, VariableDeclaration, VariableStatement, WhileStatement, } from "assemblyscript/dist/assemblyscript.js";
+export class Visitor {
+    constructor() {
+        this.currentSource = null;
+        this.depth = 0;
+    }
+    visit(node) {
+        if (node == null) {
+            return;
+        }
+        else if (node instanceof Array) {
+            for (const element of node) {
+                this.visit(element);
+            }
+        }
+        else if (node instanceof Map) {
+            for (const element of node.values()) {
+                this.visit(element);
+            }
+            // @ts-ignore
+        }
+        else if (typeof node[Symbol.iterator] === "function") {
+            // @ts-ignore
+            for (const element of node) {
+                this.visit(element);
+            }
+        }
+        else if (node instanceof Node) {
+            this._visit(node);
+        }
+        else {
+            throw new Error("Could not visit invalid type!");
+        }
+    }
+    _visit(node) {
+        if (node instanceof Source) {
+            this.visitSource(node);
+        }
+        else if (node instanceof NamedTypeNode) {
+            this.visitNamedTypeNode(node);
+        }
+        else if (node instanceof FunctionTypeNode) {
+            this.visitFunctionTypeNode(node);
+        }
+        else if (node instanceof TypeName) {
+            this.visitTypeName(node);
+        }
+        else if (node instanceof TypeParameterNode) {
+            this.visitTypeParameter(node);
+        }
+        else if (node instanceof IdentifierExpression) {
+            this.visitIdentifierExpression(node);
+        }
+        else if (node instanceof AssertionExpression) {
+            this.visitAssertionExpression(node);
+        }
+        else if (node instanceof BinaryExpression) {
+            this.visitBinaryExpression(node);
+        }
+        else if (node instanceof CallExpression) {
+            this.visitCallExpression(node);
+        }
+        else if (node instanceof ClassExpression) {
+            this.visitClassExpression(node);
+        }
+        else if (node instanceof CommaExpression) {
+            this.visitCommaExpression(node);
+        }
+        else if (node instanceof ElementAccessExpression) {
+            this.visitElementAccessExpression(node);
+        }
+        else if (node instanceof FunctionExpression) {
+            this.visitFunctionExpression(node);
+        }
+        else if (node instanceof InstanceOfExpression) {
+            this.visitInstanceOfExpression(node);
+        }
+        else if (node instanceof LiteralExpression) {
+            this.visitLiteralExpression(node);
+        }
+        else if (node instanceof NewExpression) {
+            this.visitNewExpression(node);
+        }
+        else if (node instanceof ParenthesizedExpression) {
+            this.visitParenthesizedExpression(node);
+        }
+        else if (node instanceof PropertyAccessExpression) {
+            this.visitPropertyAccessExpression(node);
+        }
+        else if (node instanceof TernaryExpression) {
+            this.visitTernaryExpression(node);
+        }
+        else if (node instanceof UnaryPostfixExpression) {
+            this.visitUnaryPostfixExpression(node);
+        }
+        else if (node instanceof UnaryPrefixExpression) {
+            this.visitUnaryPrefixExpression(node);
+        }
+        else if (node instanceof BlockStatement) {
+            this.visitBlockStatement(node);
+        }
+        else if (node instanceof BreakStatement) {
+            this.visitBreakStatement(node);
+        }
+        else if (node instanceof ContinueStatement) {
+            this.visitContinueStatement(node);
+        }
+        else if (node instanceof DoStatement) {
+            this.visitDoStatement(node);
+        }
+        else if (node instanceof EmptyStatement) {
+            this.visitEmptyStatement(node);
+        }
+        else if (node instanceof ExportStatement) {
+            this.visitExportStatement(node);
+        }
+        else if (node instanceof ExportDefaultStatement) {
+            this.visitExportDefaultStatement(node);
+        }
+        else if (node instanceof ExportImportStatement) {
+            this.visitExportImportStatement(node);
+        }
+        else if (node instanceof ExpressionStatement) {
+            this.visitExpressionStatement(node);
+        }
+        else if (node instanceof ForStatement) {
+            this.visitForStatement(node);
+        }
+        else if (node instanceof IfStatement) {
+            this.visitIfStatement(node);
+        }
+        else if (node instanceof ImportStatement) {
+            this.visitImportStatement(node);
+        }
+        else if (node instanceof ReturnStatement) {
+            this.visitReturnStatement(node);
+        }
+        else if (node instanceof SwitchStatement) {
+            this.visitSwitchStatement(node);
+        }
+        else if (node instanceof ThrowStatement) {
+            this.visitThrowStatement(node);
+        }
+        else if (node instanceof TryStatement) {
+            this.visitTryStatement(node);
+        }
+        else if (node instanceof VariableStatement) {
+            this.visitVariableStatement(node);
+        }
+        else if (node instanceof WhileStatement) {
+            this.visitWhileStatement(node);
+        }
+        else if (node instanceof ClassDeclaration) {
+            this.visitClassDeclaration(node);
+        }
+        else if (node instanceof EnumDeclaration) {
+            this.visitEnumDeclaration(node);
+        }
+        else if (node instanceof EnumValueDeclaration) {
+            this.visitEnumValueDeclaration(node);
+        }
+        else if (node instanceof FieldDeclaration) {
+            this.visitFieldDeclaration(node);
+        }
+        else if (node instanceof FunctionDeclaration) {
+            this.visitFunctionDeclaration(node);
+        }
+        else if (node instanceof ImportDeclaration) {
+            this.visitImportDeclaration(node);
+        }
+        else if (node instanceof InterfaceDeclaration) {
+            this.visitInterfaceDeclaration(node);
+        }
+        else if (node instanceof MethodDeclaration) {
+            this.visitMethodDeclaration(node);
+        }
+        else if (node instanceof NamespaceDeclaration) {
+            this.visitNamespaceDeclaration(node);
+        }
+        else if (node instanceof TypeDeclaration) {
+            this.visitTypeDeclaration(node);
+        }
+        else if (node instanceof VariableDeclaration) {
+            this.visitVariableDeclaration(node);
+        }
+        else if (node instanceof DecoratorNode) {
+            this.visitDecoratorNode(node);
+        }
+        else if (node instanceof ExportMember) {
+            this.visitExportMember(node);
+        }
+        else if (node instanceof ParameterNode) {
+            this.visitParameter(node);
+        }
+        else if (node instanceof SwitchCase) {
+            this.visitSwitchCase(node);
+        }
+        else if (node instanceof IndexSignatureNode) {
+            this.visitIndexSignature(node);
+        }
+        else {
+            throw new Error("Could not visit invalid type!");
+        }
+    }
+    visitSource(node) {
+        this.currentSource = node;
+        for (const stmt of node.statements) {
+            this.depth++;
+            this._visit(stmt);
+            this.depth--;
+        }
+        this.currentSource = null;
+    }
+    visitTypeNode(node) { }
+    visitTypeName(node) {
+        this.visit(node.identifier);
+        this.visit(node.next);
+    }
+    visitNamedTypeNode(node) {
+        this.visit(node.name);
+        this.visit(node.typeArguments);
+    }
+    visitFunctionTypeNode(node) {
+        this.visit(node.parameters);
+        this.visit(node.returnType);
+        this.visit(node.explicitThisType);
+    }
+    visitTypeParameter(node) {
+        this.visit(node.name);
+        this.visit(node.extendsType);
+        this.visit(node.defaultType);
+    }
+    visitIdentifierExpression(node) { }
+    visitArrayLiteralExpression(node) {
+        this.visit(node.elementExpressions);
+    }
+    visitObjectLiteralExpression(node) {
+        this.visit(node.names);
+        this.visit(node.values);
+    }
+    visitAssertionExpression(node) {
+        this.visit(node.toType);
+        this.visit(node.expression);
+    }
+    visitBinaryExpression(node) {
+        this.visit(node.left);
+        this.visit(node.right);
+    }
+    visitCallExpression(node) {
+        this.visit(node.expression);
+        this.visitArguments(node.typeArguments, node.args);
+    }
+    visitArguments(typeArguments, args) {
+        this.visit(typeArguments);
+        this.visit(args);
+    }
+    visitClassExpression(node) {
+        this.visit(node.declaration);
+    }
+    visitCommaExpression(node) {
+        this.visit(node.expressions);
+    }
+    visitElementAccessExpression(node) {
+        this.visit(node.elementExpression);
+        this.visit(node.expression);
+    }
+    visitFunctionExpression(node) {
+        this.visit(node.declaration);
+    }
+    visitLiteralExpression(node) {
+        if (node instanceof FloatLiteralExpression) {
+            this.visitFloatLiteralExpression(node);
+        }
+        else if (node instanceof IntegerLiteralExpression) {
+            this.visitIntegerLiteralExpression(node);
+        }
+        else if (node instanceof StringLiteralExpression) {
+            this.visitStringLiteralExpression(node);
+        }
+        else if (node instanceof TemplateLiteralExpression) {
+            this.visitTemplateLiteralExpression(node);
+        }
+        else if (node instanceof RegexpLiteralExpression) {
+            this.visitRegexpLiteralExpression(node);
+        }
+        else if (node instanceof ArrayLiteralExpression) {
+            this.visitArrayLiteralExpression(node);
+        }
+        else if (node instanceof ObjectLiteralExpression) {
+            this.visitObjectLiteralExpression(node);
+        }
+        else {
+            throw new Error("Invalid LiteralKind at visitLiteralExpression(): " + node.literalKind);
+        }
+    }
+    visitFloatLiteralExpression(node) { }
+    visitInstanceOfExpression(node) {
+        this.visit(node.expression);
+        this.visit(node.isType);
+    }
+    visitIntegerLiteralExpression(node) { }
+    visitStringLiteral(str, singleQuoted = false) { }
+    visitStringLiteralExpression(node) {
+        this.visitStringLiteral(node.value);
+    }
+    visitTemplateLiteralExpression(node) { }
+    visitRegexpLiteralExpression(node) { }
+    visitNewExpression(node) {
+        this.visit(node.typeArguments);
+        this.visitArguments(node.typeArguments, node.args);
+        this.visit(node.args);
+    }
+    visitParenthesizedExpression(node) {
+        this.visit(node.expression);
+    }
+    visitPropertyAccessExpression(node) {
+        this.visit(node.property);
+        this.visit(node.expression);
+    }
+    visitTernaryExpression(node) {
+        this.visit(node.condition);
+        this.visit(node.ifThen);
+        this.visit(node.ifElse);
+    }
+    visitUnaryExpression(node) {
+        this.visit(node.operand);
+    }
+    visitUnaryPostfixExpression(node) {
+        this.visit(node.operand);
+    }
+    visitUnaryPrefixExpression(node) {
+        this.visit(node.operand);
+    }
+    visitSuperExpression(node) { }
+    visitFalseExpression(node) { }
+    visitTrueExpression(node) { }
+    visitThisExpression(node) { }
+    visitNullExperssion(node) { }
+    visitConstructorExpression(node) { }
+    visitNodeAndTerminate(statement) { }
+    visitBlockStatement(node) {
+        this.depth++;
+        this.visit(node.statements);
+        this.depth--;
+    }
+    visitBreakStatement(node) {
+        this.visit(node.label);
+    }
+    visitContinueStatement(node) {
+        this.visit(node.label);
+    }
+    visitClassDeclaration(node, isDefault = false) {
+        this.visit(node.name);
+        this.depth++;
+        this.visit(node.decorators);
+        if (node.isGeneric ? node.typeParameters != null : node.typeParameters == null) {
+            this.visit(node.typeParameters);
+            this.visit(node.extendsType);
+            this.visit(node.implementsTypes);
+            this.visit(node.members);
+            this.depth--;
+        }
+        else {
+            throw new Error("Expected to type parameters to match class declaration, but found type mismatch instead!");
+        }
+    }
+    visitDoStatement(node) {
+        this.visit(node.condition);
+        this.visit(node.body);
+    }
+    visitEmptyStatement(node) { }
+    visitEnumDeclaration(node, isDefault = false) {
+        this.visit(node.name);
+        this.visit(node.decorators);
+        this.visit(node.values);
+    }
+    visitEnumValueDeclaration(node) {
+        this.visit(node.name);
+        this.visit(node.initializer);
+    }
+    visitExportImportStatement(node) {
+        this.visit(node.name);
+        this.visit(node.externalName);
+    }
+    visitExportMember(node) {
+        this.visit(node.localName);
+        this.visit(node.exportedName);
+    }
+    visitExportStatement(node) {
+        this.visit(node.path);
+        this.visit(node.members);
+    }
+    visitExportDefaultStatement(node) {
+        this.visit(node.declaration);
+    }
+    visitExpressionStatement(node) {
+        this.visit(node.expression);
+    }
+    visitFieldDeclaration(node) {
+        this.visit(node.name);
+        this.visit(node.type);
+        this.visit(node.initializer);
+        this.visit(node.decorators);
+    }
+    visitForStatement(node) {
+        this.visit(node.initializer);
+        this.visit(node.condition);
+        this.visit(node.incrementor);
+        this.visit(node.body);
+    }
+    visitFunctionDeclaration(node, isDefault = false) {
+        this.visit(node.name);
+        this.visit(node.decorators);
+        this.visit(node.typeParameters);
+        this.visit(node.signature);
+        this.depth++;
+        this.visit(node.body);
+        this.depth--;
+    }
+    visitIfStatement(node) {
+        this.visit(node.condition);
+        this.visit(node.ifTrue);
+        this.visit(node.ifFalse);
+    }
+    visitImportDeclaration(node) {
+        this.visit(node.foreignName);
+        this.visit(node.name);
+        this.visit(node.decorators);
+    }
+    visitImportStatement(node) {
+        this.visit(node.namespaceName);
+        this.visit(node.declarations);
+    }
+    visitIndexSignature(node) {
+        this.visit(node.keyType);
+        this.visit(node.valueType);
+    }
+    visitInterfaceDeclaration(node, isDefault = false) {
+        this.visit(node.name);
+        this.visit(node.typeParameters);
+        this.visit(node.implementsTypes);
+        this.visit(node.extendsType);
+        this.depth++;
+        this.visit(node.members);
+        this.depth--;
+    }
+    visitMethodDeclaration(node) {
+        this.visit(node.name);
+        this.visit(node.typeParameters);
+        this.visit(node.signature);
+        this.visit(node.decorators);
+        this.depth++;
+        this.visit(node.body);
+        this.depth--;
+    }
+    visitNamespaceDeclaration(node, isDefault = false) {
+        this.visit(node.name);
+        this.visit(node.decorators);
+        this.visit(node.members);
+    }
+    visitReturnStatement(node) {
+        this.visit(node.value);
+    }
+    visitSwitchCase(node) {
+        this.visit(node.label);
+        this.visit(node.statements);
+    }
+    visitSwitchStatement(node) {
+        this.visit(node.condition);
+        this.depth++;
+        this.visit(node.cases);
+        this.depth--;
+    }
+    visitThrowStatement(node) {
+        this.visit(node.value);
+    }
+    visitTryStatement(node) {
+        this.visit(node.bodyStatements);
+        this.visit(node.catchVariable);
+        this.visit(node.catchStatements);
+        this.visit(node.finallyStatements);
+    }
+    visitTypeDeclaration(node) {
+        this.visit(node.name);
+        this.visit(node.decorators);
+        this.visit(node.type);
+        this.visit(node.typeParameters);
+    }
+    visitVariableDeclaration(node) {
+        this.visit(node.name);
+        this.visit(node.type);
+        this.visit(node.initializer);
+    }
+    visitVariableStatement(node) {
+        this.visit(node.decorators);
+        this.visit(node.declarations);
+    }
+    visitWhileStatement(node) {
+        this.visit(node.condition);
+        this.depth++;
+        this.visit(node.body);
+        this.depth--;
+    }
+    visitVoidStatement(node) { }
+    visitComment(node) { }
+    visitDecoratorNode(node) {
+        this.visit(node.name);
+        this.visit(node.args);
+    }
+    visitParameter(node) {
+        this.visit(node.name);
+        this.visit(node.implicitFieldDeclaration);
+        this.visit(node.initializer);
+        this.visit(node.type);
+    }
+}

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.9.8",
+  "version": "0.9.9",
   "description": "JSON encoder/decoder for AssemblyScript",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -164,6 +164,14 @@ class JSONTransform extends BaseVisitor {
         mem.initialize = "this." + name.text + " = changetype<nonnull<" + mem.type + ">>(__new(offsetof<nonnull<" + mem.type + ">>(), idof<nonnull<" + mem.type + ">>()));\n  changetype<nonnull<" + mem.type + ">>(this." + name.text + ").__INITIALIZE()";
       } else if (mem.value) {
         mem.initialize = "this." + name.text + " = " + mem.value;
+      } else if (t === "Map") {
+        mem.initialize = "this." + name.text + " = new " + mem.type + "()"
+      } else if (t === "string") {
+        mem.initialize = "this." + name.text + " = \"\"";
+      } else if (t === "Array") {
+        mem.initialize = "this." + name.text + " = instantiate<" + mem.type + ">()";
+      } else {
+        console.log(t)
       }
 
       schema.members.push(mem);