Add temporary(?) patch for yul node IDs.

It is possible to generate IDs during AST processing by performing a deep search for the last ID in all the original source units; however, this breaks the current tests for the copy method in ASTNodeFactory, which expect hard-coded IDs for specific nodes. Since they are created *after* all of the original source units are processed, and those all have independent contexts, this does not seem like an actual issue or breaking change for consumers. Until the tests are updated or a better mechanism is determined, the current workaround is to offset yul AST nodes by 100000.

Author: d1ll0n

src/ast/ast_node_factory.ts

@@ -85,7 +85,8 @@ import {
     YulLiteral,
     YulIdentifier,
     YulFunctionCall,
-    YulTypedName
+    YulTypedName,
+    isYulASTNode
 } from "./implementation/yul";
 
 /**
@@ -821,12 +822,14 @@ export class ASTNodeFactory {
     postprocessor: ASTPostprocessor;
 
     private lastId: number;
+    private lastYulId: number;
 
     constructor(context = new ASTContext(), postprocessor = new ASTPostprocessor()) {
         this.context = context;
         this.postprocessor = postprocessor;
 
         this.lastId = context.lastId;
+        this.lastYulId = context.lastYulId;
     }
 
     makeYulAssignment(
@@ -1288,7 +1291,8 @@ export class ASTNodeFactory {
         type: ASTNodeConstructor<T>,
         ...args: Specific<ConstructorParameters<typeof type>>
     ): T {
-        const node = new type(++this.lastId, "0:0:0", ...args);
+        const id = isYulASTNode(type.prototype) ? ++this.lastYulId : ++this.lastId;
+        const node = new type(id, "0:0:0", ...args);
 
         this.context.register(node);
 

src/ast/ast_reader.ts

@@ -1,5 +1,7 @@
+// import { deepFindIn } from "../misc";
 import { ASTNode, ASTNodeConstructor } from "./ast_node";
 import { SourceUnit } from "./implementation/meta/source_unit";
+import { isYulASTNode } from "./implementation/yul";
 import { LegacyConfiguration } from "./legacy";
 import { ModernConfiguration } from "./modern";
 import { DefaultNodePostprocessorList } from "./postprocessing";
@@ -45,6 +47,12 @@ export class ASTContext {
      */
     id = contextIdSequence.next().value;
 
+    /**
+     *  Temporary workaround
+     */
+    readonly yulIdStart = 1e5;
+    lastYulId = this.yulIdStart;
+
     /**
      * Map from ID number to the `AST` node with same ID in tree
      */
@@ -61,6 +69,9 @@ export class ASTContext {
         let last = 0;
 
         for (const id of this.map.keys()) {
+            if (id >= this.yulIdStart) {
+                continue;
+            }
             if (id > last) {
                 last = id;
             }
@@ -75,6 +86,9 @@ export class ASTContext {
 
     register(...nodes: ASTNode[]): void {
         for (const node of nodes) {
+            if (node.id === undefined && isYulASTNode(node)) {
+                node.id = ++this.lastYulId;
+            }
             if (this.map.has(node.id)) {
                 throw new Error(`The id ${node.id} is already taken for the context`);
             }
@@ -190,6 +204,19 @@ export class ASTReader {
         const rootNodeTypeName = "SourceUnit";
         const result: SourceUnit[] = [];
 
+        // const nodes = entries.map((e) => e[1]);
+        // const hasAssemblyAST = deepFindIn(
+        //     nodes,
+        //     "nodeType",
+        //     (node: any) => node.nodeType.startsWith("Yul"),
+        //     true
+        // );
+        // if (hasAssemblyAST) {
+        //     const ids = deepFindIn(nodes, "id", (id) => typeof id === "number");
+        //     const lastId = Math.max(...ids);
+        //     this.context.lastOriginalId = lastId;
+        // }
+
         for (const [key, content] of entries) {
             let ast;
 

test/unit/misc/utils/deepFindIn.spec.ts

@@ -0,0 +1,51 @@
+import expect from "expect";
+import { deepFindIn } from "../../../../src";
+
+const testObject = {
+    type: "SourceUnit",
+    id: 0,
+    children: [
+        {
+            id: 2,
+            type: "FunctionDefinition",
+            vParameters: {
+                a: 1,
+                b: 3,
+                c: {
+                    id: 1
+                }
+            }
+        },
+        [[{ id: 5 }], { id: "6" }, { x: 2 }]
+    ]
+};
+
+const cases: Array<[string, any, ((obj: any) => any) | undefined, any[], ...([boolean] | [])]> = [
+    [
+        "Returns deeply nested obj[matchKey] when no callback is provided",
+        "id",
+        undefined,
+        [0, 2, 1, 5, "6"]
+    ],
+    [
+        "Returns deeply nested obj[matchKey] when cb returns true",
+        "id",
+        (obj) => typeof obj.id === "number" && obj.id > 1,
+        [2, 5]
+    ],
+    [
+        "Returns cb response when it is not true or falsey",
+        "0",
+        (arr) => arr.length === 2 && arr[0]?.type,
+        ["FunctionDefinition"]
+    ],
+    ["Stops at first result if match found", "id", undefined, [0], true]
+];
+
+describe("deepFindIn()", () => {
+    for (const [title, key, cb, expectation, onlyFirst] of cases) {
+        it(`${title}`, () => {
+            expect(deepFindIn(testObject, key, cb, onlyFirst)).toMatchObject(expectation);
+        });
+    }
+});