json-as 1.1.16 → 1.1.17

package/transform/src/types.ts

@@ -1,6 +1,6 @@
-import { ClassDeclaration, Expression, FieldDeclaration, Source } from "assemblyscript/dist/assemblyscript.js";
+import { ClassDeclaration, Expression, FieldDeclaration, Source, NodeKind, Node, NamespaceDeclaration, DeclarationStatement, TypeName, Parser, ImportStatement, CommonFlags } from "assemblyscript/dist/assemblyscript.js";
 import { TypeAlias } from "./linkers/alias.js";
-import { JSONTransform, stripNull } from "./index.js";
+import { stripNull } from "./index.js";
 
 export enum PropertyFlags {
   OmitNull,
@@ -75,14 +75,192 @@ export class Schema {
   }
 }
 
+export class SourceSet {
+  private sources: Record<string, Src> = {};
+
+  /**
+   * Get a stored source from the set, or create a new one and store it if it
+   * didn't exist.
+   * @param source AssemblyScript Source
+   * @returns Source object
+   */
+  get(source: Source): Src {
+    let src = this.sources[source.internalPath];
+    if (!src) {
+      src = new Src(source, this);
+      this.sources[source.internalPath] = src;
+    }
+    return src;
+  }
+}
+
 export class Src {
   public internalPath: string;
+  public normalizedPath: string;
   public schemas: Schema[];
   public aliases: TypeAlias[];
-  public imports: Schema[];
   public exports: Schema[];
-  constructor(source: Source) {
+  private nodeMap: Map<Node, NamespaceDeclaration[]> = new Map<Node, NamespaceDeclaration[]>();
+  private classes: Record<string, ClassDeclaration> = {};
+  private imports: ImportStatement[] = [];
+
+  constructor(
+    source: Source,
+    private sourceSet: SourceSet,
+  ) {
     this.internalPath = source.internalPath;
+    this.normalizedPath = source.normalizedPath;
     this.aliases = TypeAlias.getAliases(source);
+    this.traverse(source.statements, []);
+  }
+
+  /**
+   * Traverse source nodes and finds all classes and imports, and which namespaces they exist under.
+   * @param nodes Nodes to traverse.
+   * @param path The current path of namespace declarations leading to the nodes.
+   */
+  private traverse(nodes: Node[], path: NamespaceDeclaration[]) {
+    for (let node of nodes) {
+      switch (node.kind) {
+        case NodeKind.NamespaceDeclaration:
+          const namespaceDeclaration = node as NamespaceDeclaration;
+          this.traverse(namespaceDeclaration.members, [...path, namespaceDeclaration]);
+          break;
+        case NodeKind.ClassDeclaration:
+          const classDeclaration = node as ClassDeclaration;
+          this.classes[this.qualifiedName(classDeclaration, path)] = classDeclaration;
+          break;
+        case NodeKind.Import:
+          const importStatement = node as ImportStatement;
+          this.imports.push(importStatement);
+          break;
+      }
+      this.nodeMap.set(node, path);
+    }
+  }
+
+  /**
+   * Get the qualified name (eg. "Namespace.BaseObject") for a class.
+   * @param node Class declaration.
+   * @returns Qualified name
+   */
+  getQualifiedName(node: DeclarationStatement): string {
+    return this.qualifiedName(node, this.nodeMap.get(node));
+  }
+
+  /**
+   * Get a class declaration by its qualified name.
+   * @param qualifiedName Qualified named (eg. "Namespace.BaseObject")
+   * @returns Class declaration or null if not found.
+   */
+  getClass(qualifiedName: string): ClassDeclaration | null {
+    return this.classes[qualifiedName] || null;
+  }
+
+  /**
+   * Get imported class from other sources in the parser.
+   * @param qualifiedName Qualified name of class.
+   * @param parser AssemblyScript parser.
+   * @returns Class declaration or null if not found.
+   */
+  getImportedClass(qualifiedName: string, parser: Parser): ClassDeclaration | null {
+    for (const stmt of this.imports) {
+      const externalSource = parser.sources.filter((src) => src.internalPath != this.internalPath).find((src) => src.internalPath == stmt.internalPath);
+      if (!externalSource) continue;
+
+      const source = this.sourceSet.get(externalSource);
+      const classDeclaration = source.getClass(qualifiedName);
+      if (classDeclaration && classDeclaration.flags & CommonFlags.Export) {
+        return classDeclaration;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Gets a unique path string to the node by combining the internalPath with
+   * the qualified name of the node.
+   * @param node DeclarationStatement
+   */
+  getFullPath(node: DeclarationStatement): string {
+    return this.internalPath + "/" + this.getQualifiedName(node);
+  }
+
+  /**
+   * Resolved the qualified name of the extended class for a class
+   * declaration.
+   * @param classDeclaration Class declaration that extends another class.
+   * @returns Qualified name of the extended class, or empty string if not extending any class.
+   */
+  resolveExtendsName(classDeclaration: ClassDeclaration): string {
+    const parents = this.nodeMap.get(classDeclaration);
+    if (!classDeclaration.extendsType || !parents) {
+      return "";
+    }
+
+    const name = classDeclaration.extendsType.name.identifier.text;
+    const extendsName = this.getIdentifier(classDeclaration.extendsType.name);
+
+    // Reverse walk to find first class or namespace that matches the first part
+    // of type name.
+    for (let i = parents.length - 1; i >= 0; i--) {
+      const parent = parents[i];
+      for (let node of parent.members) {
+        if (name == this.getNamespaceOrClassName(node)) {
+          // Add namespace path to the extendsName.
+          return (
+            parents
+              .slice(0, i + 1)
+              .map((p) => p.name.text)
+              .join(".") +
+            "." +
+            extendsName
+          );
+        }
+      }
+    }
+    // No matching class or namespace found. Just use the extendsName.
+    return extendsName;
+  }
+
+  /**
+   * Get the qualified name (eg "Namespace.BaseObject") of a class.
+   * @param node Class declaration.
+   * @param parents Array of namespace parents.
+   * @returns Qualified name
+   */
+  private qualifiedName(node: DeclarationStatement, parents: NamespaceDeclaration[]): string {
+    return parents?.length ? parents.map((p) => p.name.text).join(".") + "." + node.name.text : node.name.text;
+  }
+
+  /**
+   * Checks if the node is either a namespace or class, and returns the simple
+   * name of the node.
+   * @param node Node to check
+   * @returns Name of namespace or class, or empty string if other type of node.
+   */
+  private getNamespaceOrClassName(node: Node): string {
+    switch (node.kind) {
+      case NodeKind.NamespaceDeclaration:
+        return (node as DeclarationStatement).name.text;
+      case NodeKind.ClassDeclaration:
+        return (node as DeclarationStatement).name.text;
+    }
+    return "";
+  }
+
+  /**
+   * Get the full name (eg. "Namespace.Base") of a type name such as an
+   * extendedType.
+   * @param typeName Type name
+   * @returns Full name
+   */
+  private getIdentifier(typeName: TypeName): string {
+    let names = [];
+    while (typeName) {
+      names.push(typeName.identifier.text);
+      typeName = typeName.next;
+    }
+    return names.join(".");
   }
 }

package/transform/src/linkers/classes.ts

@@ -1,50 +0,0 @@
-import { ClassDeclaration, CommonFlags, NodeKind, Parser, Source } from "assemblyscript/dist/assemblyscript.js";
-import { Visitor } from "../visitor.js";
-import { getImports } from "./imports.js";
-
-export function getImportedClass(name: string, source: Source, parser: Parser): ClassDeclaration | null {
-  for (const stmt of getImports(source)) {
-    const externalSource = parser.sources.filter((src) => src.internalPath != source.internalPath).find((src) => src.internalPath == stmt.internalPath);
-    if (!externalSource) continue;
-
-    const classDeclaration = ClassGetter.getClass(name, externalSource);
-    if (!classDeclaration) continue;
-    if (!(classDeclaration.flags & CommonFlags.Export)) continue;
-    return classDeclaration;
-  }
-  return null;
-}
-
-class ClassGetter extends Visitor {
-  static SN: ClassGetter = new ClassGetter();
-
-  private classes: ClassDeclaration[] = [];
-
-  visitClassDeclaration(node: ClassDeclaration): void {
-    this.classes.push(node);
-  }
-
-  // visitTypeName(node: TypeName, ref?: Node | null): void {}
-  // visitParameter(node: ParameterNode, ref?: Node | null): void {}
-  // visitFunctionTypeNode(node: FunctionTypeNode, ref?: Node | null): void {}
-  // visitNamedTypeNode(node: NamedTypeNode, ref?: Node | null): void {}
-
-  static getClass(name: string, source: Source): ClassDeclaration | null {
-    return ClassGetter.getClasses(source).find((c) => c.name.text == name) || null;
-  }
-
-  static getClasses(source: Source): ClassDeclaration[] {
-    // ClassGetter.SN.classes = [];
-    // ClassGetter.SN.visit(source);
-    // return ClassGetter.SN.classes;
-    return source.statements.filter((stmt) => stmt.kind == NodeKind.ClassDeclaration) as ClassDeclaration[];
-  }
-}
-
-export function getClasses(source: Source): ClassDeclaration[] {
-  return ClassGetter.getClasses(source);
-}
-
-export function getClass(name: string, source: Source): ClassDeclaration | null {
-  return ClassGetter.getClass(name, source);
-}