refactor: rework the existing code with the new syntax parser (#246)

* refactor: some many changes

* fix: fixing all the tests and regex

* refactor: cleaning unused code

Author: DaanV2

src/graph/mermaid.ts

@@ -106,11 +106,11 @@ flowchart ${this.options.direction}`;
 
       case NodeType.FunctionCall:
         const funcName = node.names.join(".");
-        return createNodeInfo(`{{"${node.namespace}.${funcName}()${position}"}}`, `${node.namespace}.${funcName}()`);
+        return createNodeInfo(`{{"${node.scope}.${funcName}()${position}"}}`, `${node.scope}.${funcName}()`);
 
       case NodeType.ResourceReference:
         const resName = node.names.join(".");
-        return createNodeInfo(`[/"${node.namespace}.${resName}${position}"/]`, `${node.namespace}.${resName}`);
+        return createNodeInfo(`[/"${node.scope}.${resName}${position}"/]`, `${node.scope}.${resName}`);
 
       default:
         return {

src/main.ts

@@ -1,3 +1,2 @@
 export * from "./data";
 export * as Molang from "./molang";
-export * from "./types/defined";

src/molang/cache.ts

@@ -0,0 +1,37 @@
+import { OffsetWord } from "bc-minecraft-bedrock-types/lib/types";
+import { ExpressionNode, parseMolang } from "./syntax";
+
+export class MolangSyntaxCache {
+  private _data: Map<string, ExpressionNode[]>;
+
+  constructor() {
+    this._data = new Map();
+  }
+
+  build(code: OffsetWord): ExpressionNode[] | undefined {
+    const exp = this._data.get(code.text);
+    if (exp === undefined) {
+      const r = parseMolang(code);
+      this._data.set(code.text, r);
+      return r;
+    }
+
+    return exp;
+  }
+
+  clear() {
+    this._data.clear();
+  }
+
+  entries() {
+    return this._data.entries();
+  }
+
+  syntaxes() {
+    return this._data.keys();
+  }
+
+  expressions() {
+    return this._data.values();
+  }
+}

src/molang/functions.ts

@@ -21,14 +21,18 @@ const molangRegexp =
  * @param data The string to check
  * @returns The type of molang
  */
-export function IsMolangType(data: string): MolangType {
+export function isMolangType(data: string): MolangType {
   if (commandRegex.test(data)) return MolangType.command;
   if (eventRegex.test(data)) return MolangType.event;
   if (molangRegexp.test(data)) return MolangType.molang;
 
   return MolangType.unknown;
 }
 
+export function isMolang(data: string) {
+  return molangRegexp.test(data);
+}
+
 /**
  * Already assumes that the given data is of type MolangType.event
  * @param data The text to parse

src/molang/index.ts

@@ -1,7 +1,5 @@
 /*	Auto generated	*/
-export * as Types from "./types/index";
 export * from "./functions";
 export * from "./molang-set";
-export * from "./regexp";
 export * from "./syntax";
-export * from "./traverse";
+export * from "./traverse";

src/molang/molang-set.ts

@@ -1,157 +1,79 @@
-import { DefinedUsing } from "../types/defined/defined-using";
-import { Using } from "../types/defined";
-import { Context, Queries, Temps, Variables, Geometries, Textures, Materials } from "./types";
-
-/** Can either be a MolangSet or a MolangSet[] */
-export type MolangSetOptional = MolangSet | MolangFullSet;
+import { OffsetWord } from "bc-minecraft-bedrock-types/lib/types";
+import { MolangSyntaxCache } from "./cache";
+import { isMolang, isValidMolang } from "./functions";
+import { ExpressionNode, FunctionCallNode, NodeType, ResourceReferenceNode, VariableNode, walk } from "./syntax";
 
 /** The interface for the molang set */
-export interface MolangSet {
-  /** The set of contexts variables used*/
-  contexts: Using<string>;
-  /** The set of queries used */
-  queries: Using<string>;
-  /** The set of variables defined and used*/
-  variables: DefinedUsing<string>;
-  /** The set of temps variables defined and used*/
-  temps: DefinedUsing<string>;
-}
+export class MolangSet {
+  public cache = new MolangSyntaxCache();
+  public assigned = new Set<ResourceReferenceNode | VariableNode>();
+  public functions = new Set<FunctionCallNode>();
+  public using = new Set<ResourceReferenceNode | VariableNode>();
 
-/** The interface for the molang with the full set of data */
-export interface MolangFullSet extends MolangSet {
-  /** The set of geometries used */
-  geometries: DefinedUsing<string>;
-  /** The set of materials used */
-  materials: DefinedUsing<string>;
-  /** The set of textures used */
-  textures: DefinedUsing<string>;
-}
+  constructor() {}
 
-/** The namespace for the molang set */
-export namespace MolangSet {
   /**
-   * Creates a new MolangSet
-   * @returns A new MolangSet
+   * adds the data from the molang code if it is valid molang
+   * @param molang
    */
-  export function create(): MolangSet {
-    return {
-      queries: Using.create<string>(),
-      variables: DefinedUsing.create<string>(),
-      temps: DefinedUsing.create<string>(),
-      contexts: Using.create<string>(),
-    };
+  addIf(molang: OffsetWord) {
+    if (isValidMolang(molang.text)) this.add(molang);
   }
 
   /**
-   * Harvests molang data from the given object
-   * @param object The object to harvest from
-   * @returns The molang data
+   *
+   * @param molang
+   * @returns
    */
-  export function harvest(object: any): MolangSet {
-    const out = create();
-
-    Queries.getUsing(object, out.queries.using);
-    Context.getUsing(object, out.contexts.using);
-
-    Variables.getUsing(object, out.variables.using);
-    Variables.getDefined(object, out.variables.defined);
-
-    Temps.getUsing(object, out.temps.using);
-    Temps.getDefined(object, out.temps.defined);
-
-    return out;
+  add(molang: OffsetWord) {
+    const exp = this.cache.build(molang);
+    if (exp === undefined) return;
+    exp.forEach((e) => walk(e, this.walkFn.bind(this)));
   }
-}
 
-/** The namespace for the full molang set */
-export namespace MolangFullSet {
-  /**
-   * Creates a new MolangFullSet
-   * @returns A new MolangFullSet
-   */
-  export function create(): MolangFullSet {
-    return {
-      queries: Using.create<string>(),
-      variables: DefinedUsing.create<string>(),
-      temps: DefinedUsing.create<string>(),
-      contexts: Using.create<string>(),
-      geometries: DefinedUsing.empty(),
-      materials: DefinedUsing.empty(),
-      textures: DefinedUsing.empty(),
-    };
-  }
-
-  /**
-   * Add the necessary properties to the given data set to the full MolangFullSet
-   * @param data The data to add to
-   */
-  export function upgrade(data: MolangSet): MolangFullSet {
-    const out = data as MolangFullSet;
-
-    if (!DefinedUsing.is<string>(out.geometries)) out.geometries = DefinedUsing.empty();
-    if (!DefinedUsing.is<string>(out.materials)) out.materials = DefinedUsing.empty();
-    if (!DefinedUsing.is<string>(out.textures)) out.textures = DefinedUsing.empty();
-
-    return out;
-  }
-
-  /**
-   * Harvests molang data from the given object
-   * @param object The object to harvest from
-   */
-  export function harvest(object: object | string): MolangFullSet {
-    const out = create();
-
-    Queries.getUsing(object, out.queries.using);
-    Context.getUsing(object, out.contexts.using);
-
-    Variables.getUsing(object, out.variables.using);
-    Variables.getDefined(object, out.variables.defined);
-
-    Temps.getUsing(object, out.temps.using);
-    Temps.getDefined(object, out.temps.defined);
-
-    Textures.getUsing(object, out.textures.using);
-    Geometries.getUsing(object, out.geometries.using);
-    Materials.getUsing(object, out.materials.using);
-
-    return out;
+  private walkFn(node: ExpressionNode): void {
+    switch (node.type) {
+      case NodeType.Assignment:
+        this.checkAssigned(node.left);
+        break;
+      case NodeType.FunctionCall:
+        this.functions.add(node);
+        break;
+      case NodeType.ResourceReference:
+      case NodeType.Variable:
+        if (this.assigned.has(node)) break;
+        this.using.add(node);
+        break;
+    }
   }
 
-  /**
-   * Merges the given MolangFullSet into the given MolangFullSet
-   * @param value
-   */
-  export function isEither(value: MolangSetOptional): value is MolangFullSet {
-    const temp = value as MolangFullSet;
-
-    if (
-      typeof temp.geometries === "object" &&
-      typeof temp.materials === "object" &&
-      typeof temp.textures === "object"
-    ) {
-      return true;
+  private checkAssigned(node: ExpressionNode): void {
+    switch (node.type) {
+      case NodeType.ResourceReference:
+      case NodeType.Variable:
+        this.assigned.add(node);
+        break;
     }
-
-    return false;
   }
 
-  export function fromScript(script: { variables?: Record<string, string> }, addTo: MolangSet): void {
-    if (script.variables) {
-      const keys = Object.getOwnPropertyNames(script.variables);
+  harvest(object: Record<string, any> | string, originalText: string) {
+    if (typeof object === "string") {
+      if (isMolang(object)) {
+        this.add(OffsetWord.create(object, originalText.indexOf(object)));
+        return;
+      }
+    }
 
-      for (let I = 0; I < keys.length; I++) {
-        const key = keys[I];
-        if (typeof key !== "string") {
-          continue;
-        }
-        const index = key.indexOf(".");
-        if (index < 0) {
-          continue;
+    for (const [, value] of Object.entries(object)) {
+      if (typeof value === "string") {
+        if (isMolang(value)) {
+          this.add(OffsetWord.create(value, originalText.indexOf(value)));
         }
-        const id = key.substring(index + 1);
-        if (id && id.length > 0) {
-          addTo.variables.defined.push(id);
+      } else if (typeof value === "object") {
+        if (Array.isArray(value)) {
+          value.forEach((v) => this.harvest(v, originalText));
+        } else {
+          this.harvest(value, originalText);
         }
       }
     }