(WIP) Add support for Yul AST nodes (addresses #163)

src/ast/ast_node_formatter.ts

@@ -1,4 +1,4 @@
-import { ASTContext, ASTNode } from "./";
+import { ASTContext, ASTNode, YulASTNode, YulASTNodeWithChildren } from "./";
 
 const INDENT = " ".repeat(4);
 const SKIP = new Set(["requiredContext", "raw", "ownChildren"]);
@@ -82,6 +82,9 @@ export class ASTNodeFormatter {
     }
 
     private formatNode(node: ASTNode, level: number, depth: number): string {
+        if (node instanceof YulASTNode || node instanceof YulASTNodeWithChildren) {
+            return this.formatValue(node.raw);
+        }
         const output = [];
         const value = this.formatNodeValue(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;
 

src/ast/constants.ts

@@ -72,6 +72,12 @@ export enum LiteralKind {
     UnicodeString = "unicodeString"
 }
 
+export enum YulLiteralKind {
+    Number = "number",
+    Bool = "bool",
+    String = "string"
+}
+
 export enum EtherUnit {
     Wei = "wei",
     GWei = "gwei",

src/ast/documentation.ts

@@ -21,8 +21,8 @@ export interface WithDanglingDocs {
     danglingDocString?: string;
 }
 
-export function getDocumentation(
-    node: WithPrecedingDocs & ASTNodeWithChildren<ASTNode>
+export function getDocumentation<T extends ASTNode = ASTNode>(
+    node: WithPrecedingDocs & ASTNodeWithChildren<T>
 ): string | StructuredDocumentation | undefined {
     if (node.docString !== undefined) {
         return node.docString;
@@ -50,8 +50,8 @@ export function getDocumentation(
     return undefined;
 }
 
-export function setDocumentation(
-    node: WithPrecedingDocs & ASTNodeWithChildren<ASTNode>,
+export function setDocumentation<T extends ASTNode = ASTNode>(
+    node: WithPrecedingDocs & ASTNodeWithChildren<T>,
     value: string | StructuredDocumentation | undefined
 ): void {
     const old = node.documentation;
@@ -61,22 +61,22 @@ export function setDocumentation(
 
         if (old instanceof StructuredDocumentation) {
             if (value !== old) {
-                node.replaceChild(value, old);
+                node.replaceChild(value as any, old as any);
             }
         } else {
-            node.insertAtBeginning(value);
+            node.insertAtBeginning(value as any);
         }
     } else {
         if (old instanceof StructuredDocumentation) {
-            node.removeChild(old);
+            node.removeChild(old as any);
         }
 
         node.docString = value;
     }
 }
 
-export function getDanglingDocumentation(
-    node: WithDanglingDocs & ASTNodeWithChildren<ASTNode>
+export function getDanglingDocumentation<T extends ASTNode = ASTNode>(
+    node: WithDanglingDocs & ASTNodeWithChildren<T>
 ): string | StructuredDocumentation | undefined {
     if (node.danglingDocString !== undefined) {
         return node.danglingDocString;
@@ -104,8 +104,8 @@ export function getDanglingDocumentation(
     return undefined;
 }
 
-export function setDanglingDocumentation(
-    node: WithDanglingDocs & ASTNodeWithChildren<ASTNode>,
+export function setDanglingDocumentation<T extends ASTNode = ASTNode>(
+    node: WithDanglingDocs & ASTNodeWithChildren<T>,
     value: string | StructuredDocumentation | undefined
 ): void {
     const old = node.danglingDocumentation;

src/ast/implementation/index.ts

@@ -0,0 +1,6 @@
+export * from "./declaration";
+export * from "./expression";
+export * from "./meta";
+export * from "./statement";
+export * from "./type";
+export * from "./yul";

src/ast/implementation/statement/inline_assembly.ts

@@ -1,4 +1,6 @@
+import { ASTNode } from "../../ast_node";
 import { StructuredDocumentation } from "../meta";
+import { YulBlock } from "../yul";
 import { Statement } from "./statement";
 
 export interface YulNode {
@@ -12,7 +14,7 @@ export class InlineAssembly extends Statement {
     externalReferences: any[];
 
     operations?: string;
-    yul?: YulNode;
+    yul?: YulBlock;
 
     flags?: string[];
     evmVersion?: string;
@@ -22,7 +24,7 @@ export class InlineAssembly extends Statement {
         src: string,
         externalReferences: any[],
         operations?: string,
-        yul?: YulNode,
+        yul?: YulBlock,
         flags?: string[],
         evmVersion?: string,
         documentation?: string | StructuredDocumentation,
@@ -35,5 +37,10 @@ export class InlineAssembly extends Statement {
         this.yul = yul;
         this.flags = flags;
         this.evmVersion = evmVersion;
+        this.acceptChildren();
+    }
+
+    get children(): ASTNode[] {
+        return this.pickNodes(this.documentation, this.yul);
     }
 }

src/ast/implementation/yul/expression/index.ts

@@ -0,0 +1,5 @@
+export * from "./yul_expression";
+export * from "./yul_function_call";
+export * from "./yul_literal";
+export * from "./yul_identifier";
+export * from "./yul_typed_name";

src/ast/implementation/yul/expression/yul_expression.ts

@@ -0,0 +1,3 @@
+import { YulASTNode } from "../yul_ast_node";
+
+export class YulExpression extends YulASTNode {}

src/ast/implementation/yul/expression/yul_function_call.ts

@@ -0,0 +1,56 @@
+import { ExternalReferenceType } from "../../../constants";
+import { YulIdentifier } from "./yul_identifier";
+import { YulExpression } from "./yul_expression";
+import { YulFunctionDefinition } from "../statement/yul_function_definition";
+import { YulASTNode } from "../yul_ast_node";
+
+export class YulFunctionCall extends YulExpression {
+    /**
+     * YulIdentifier that defines the callee
+     */
+    vFunctionName: YulIdentifier;
+
+    /**
+     * Call arguments, e.g array with `1` and `2` expressions in `foo(1, 2)`
+     */
+    vArguments: YulExpression[];
+
+    constructor(
+        id: number,
+        src: string,
+        functionName: YulIdentifier,
+        args: YulExpression[],
+        raw?: any
+    ) {
+        super(id, src, raw);
+        this.vFunctionName = functionName;
+        this.vArguments = args;
+
+        this.acceptChildren();
+    }
+
+    get children(): readonly YulASTNode[] {
+        return this.pickNodes(this.vFunctionName, this.vArguments);
+    }
+
+    /**
+     * Identifier of the function name, e.g. `sha3(...)`
+     */
+    get vIdentifier(): string {
+        return this.vFunctionName.name;
+    }
+
+    /**
+     * Solidity builtin or user-defined function
+     */
+    get vFunctionCallType(): ExternalReferenceType {
+        return this.vFunctionName.vIdentifierType;
+    }
+
+    /**
+     * Called function definition reference
+     */
+    get vReferencedDeclaration(): YulFunctionDefinition | undefined {
+        return this.vFunctionName.vReferencedDeclaration as YulFunctionDefinition;
+    }
+}

src/ast/implementation/yul/expression/yul_identifier.ts

@@ -0,0 +1,52 @@
+import { ASTNode } from "../../../ast_node";
+import { ExternalReferenceType } from "../../../constants";
+import { YulExpression } from "./yul_expression";
+
+export class YulIdentifier extends YulExpression {
+    /**
+     * Name of the identifier
+     */
+    name: string;
+
+    /**
+     * Id of the referenced declaration
+     */
+    referencedDeclaration: number;
+
+    constructor(id: number, src: string, name: string, referencedDeclaration?: number, raw?: any) {
+        super(id, src, raw);
+
+        this.name = name;
+        this.referencedDeclaration = referencedDeclaration ?? -1;
+    }
+
+    /**
+     * Attribute to access the converted referenced declaration.
+     *
+     * Is `undefined` when this is a Solidity internal identifier.
+     */
+    get vReferencedDeclaration(): ASTNode | undefined {
+        return this.requiredContext.locate(this.referencedDeclaration);
+    }
+
+    set vReferencedDeclaration(value: ASTNode | undefined) {
+        if (value === undefined) {
+            this.referencedDeclaration = -1;
+        } else {
+            if (!this.requiredContext.contains(value)) {
+                throw new Error(`Node ${value.type}#${value.id} not belongs to a current context`);
+            }
+
+            this.referencedDeclaration = value.id;
+        }
+    }
+
+    /**
+     * Solidity builtin or user-defined reference
+     */
+    get vIdentifierType(): ExternalReferenceType {
+        return this.vReferencedDeclaration
+            ? ExternalReferenceType.UserDefined
+            : ExternalReferenceType.Builtin;
+    }
+}

src/ast/implementation/yul/expression/yul_literal.ts

@@ -0,0 +1,41 @@
+import { YulLiteralKind } from "../../../constants";
+import { YulExpression } from "./yul_expression";
+
+export class YulLiteral extends YulExpression {
+    /**
+     * The type of literal: `number`, `string` or `bool`
+     */
+    kind: YulLiteralKind;
+
+    /**
+     * Hexadecimal representation of value of the literal symbol
+     */
+    hexValue: string;
+
+    /**
+     * Value of the literal symbol
+     */
+    value: string;
+
+    /**
+     * Yul type string, e.g.u256
+     */
+    typeString: string;
+
+    constructor(
+        id: number,
+        src: string,
+        kind: YulLiteralKind,
+        value: string,
+        hexValue: string,
+        typeString = "",
+        raw?: any
+    ) {
+        super(id, src, raw);
+
+        this.kind = kind;
+        this.value = value;
+        this.hexValue = hexValue;
+        this.typeString = typeString;
+    }
+}

src/ast/implementation/yul/expression/yul_typed_name.ts

@@ -0,0 +1,20 @@
+import { YulExpression } from "./yul_expression";
+
+export class YulTypedName extends YulExpression {
+    /**
+     * Name of the identifier
+     */
+    name: string;
+
+    /**
+     * Yul type string, e.g.u256
+     */
+    typeString: string;
+
+    constructor(id: number, src: string, name: string, typeString = "", raw?: any) {
+        super(id, src, raw);
+
+        this.name = name;
+        this.typeString = typeString;
+    }
+}

src/ast/implementation/yul/index.ts

@@ -0,0 +1,3 @@
+export * from "./expression";
+export * from "./statement";
+export * from "./yul_ast_node";

src/ast/implementation/yul/statement/index.ts

@@ -0,0 +1,13 @@
+export * from "./yul_assignment";
+export * from "./yul_block";
+export * from "./yul_break";
+export * from "./yul_case";
+export * from "./yul_continue";
+export * from "./yul_expression_statement";
+export * from "./yul_for_loop";
+export * from "./yul_function_definition";
+export * from "./yul_if";
+export * from "./yul_leave";
+export * from "./yul_statement";
+export * from "./yul_switch";
+export * from "./yul_variable_declaration";