Merge pull request #56 from ConsenSys/ast-postprocessing-priority

Priority-based AST postprocessing
Consensys · Aug 25, 2021 · 5300261 · 5300261
2 parents 35d7167 + e895e0a
commit 5300261
Show file tree

Hide file tree

Showing 10 changed files with 65 additions and 84 deletions.
diff --git a/src/ast/ast_node_factory.ts b/src/ast/ast_node_factory.ts
@@ -1087,7 +1087,7 @@ export class ASTNodeFactory {
     ): T {
         const node = this.makeUnfinalized(type, ...args);
 
-        this.postprocessor.process(node, this.context);
+        this.postprocessor.processNode(node, this.context);
 
         return node;
     }
@@ -1101,7 +1101,7 @@ export class ASTNodeFactory {
         for (const child of clone.getChildren(true)) {
             this.patchIds(child, cache);
 
-            postprocessor.process(child, context);
+            postprocessor.processNode(child, context);
         }
 
         return clone;

diff --git a/src/ast/ast_reader.ts b/src/ast/ast_reader.ts
@@ -2,7 +2,7 @@ import { ASTNode, ASTNodeConstructor } from "./ast_node";
 import { SourceUnit } from "./implementation/meta/source_unit";
 import { LegacyConfiguration } from "./legacy";
 import { ModernConfiguration } from "./modern";
-import { DefaultPostprocessorMapping } from "./postprocessing/mapping";
+import { DefaultNodePostprocessorList } from "./postprocessing";
 import { sequence } from "./utils";
 
 export interface ASTNodeProcessor<T extends ASTNode> {
@@ -13,6 +13,11 @@ export interface ASTNodeProcessor<T extends ASTNode> {
     ): ConstructorParameters<ASTNodeConstructor<T>>;
 }
 
+export interface ASTNodePostprocessor<T extends ASTNode> {
+    process(node: T, context: ASTContext, sources?: Map<string, string>): void;
+    isSupportedNode(node: ASTNode): node is T;
+}
+
 export interface ASTReadingRule {
     constructor: ASTNodeConstructor<ASTNode>;
     processor: ASTNodeProcessor<ASTNode>;
@@ -115,28 +120,36 @@ export class ASTContext {
     }
 }
 
-export interface ASTNodePostprocessor {
-    process(node: ASTNode, context: ASTContext, sources?: Map<string, string>): void;
-}
-
 export class ASTPostprocessor {
-    mapping: Map<ASTNodeConstructor<ASTNode>, ASTNodePostprocessor[]>;
+    nodePostprocessors: Array<ASTNodePostprocessor<ASTNode>>;
 
-    constructor(mapping = DefaultPostprocessorMapping) {
-        this.mapping = mapping;
+    constructor(nodePostProcessors = DefaultNodePostprocessorList) {
+        this.nodePostprocessors = nodePostProcessors;
     }
 
-    process(node: ASTNode, context: ASTContext, sources?: Map<string, string>): void {
-        const postprocessors = this.mapping.get(node.constructor as ASTNodeConstructor<ASTNode>);
+    getPostprocessorsForNode(node: ASTNode): Array<ASTNodePostprocessor<ASTNode>> {
+        return this.nodePostprocessors.filter((postprocessor) =>
+            postprocessor.isSupportedNode(node)
+        );
+    }
 
-        if (postprocessors === undefined) {
-            return;
-        }
+    processNode(node: ASTNode, context: ASTContext, sources?: Map<string, string>): void {
+        const postprocessors = this.getPostprocessorsForNode(node);
 
         for (const postprocessor of postprocessors) {
             postprocessor.process(node, context, sources);
         }
     }
+
+    processContext(context: ASTContext, sources?: Map<string, string>): void {
+        for (const postprocessor of this.nodePostprocessors) {
+            for (const node of context.nodes) {
+                if (postprocessor.isSupportedNode(node)) {
+                    postprocessor.process(node, context, sources);
+                }
+            }
+        }
+    }
 }
 
 export enum ASTKind {
@@ -209,12 +222,7 @@ export class ASTReader {
             result.push(sourceUnit);
         }
 
-        const context = this.context;
-        const postprocessor = this.postprocessor;
-
-        for (const node of context.nodes) {
-            postprocessor.process(node, context, sources);
-        }
+        this.postprocessor.processContext(this.context, sources);
 
         return result;
     }

diff --git a/src/ast/implementation/declaration/enum_definition.ts b/src/ast/implementation/declaration/enum_definition.ts
@@ -54,4 +54,16 @@ export class EnumDefinition extends ASTNodeWithChildren<EnumValue> {
     get vScope(): ContractDefinition | SourceUnit {
         return this.parent as ContractDefinition | SourceUnit;
     }
+
+    toUintTypeString(): string {
+        const length = this.children.length;
+
+        for (let n = 8; n <= 32; n += 8) {
+            if (length < 2 ** n) {
+                return "uint" + n;
+            }
+        }
+
+        throw new Error("Unable to detect enum type size - member count exceeds 2 ** 32");
+    }
 }
diff --git a/src/ast/implementation/declaration/variable_declaration.ts b/src/ast/implementation/declaration/variable_declaration.ts
@@ -184,17 +184,7 @@ export class VariableDeclaration extends ASTNode {
                 }
 
                 if (declaration instanceof EnumDefinition) {
-                    const length = declaration.children.length;
-
-                    for (let n = 8; n <= 32; n += 8) {
-                        if (length < 2 ** n) {
-                            return "uint" + n;
-                        }
-                    }
-
-                    throw new Error(
-                        "Unable to detect enum type size - member count exceeds 2 ** 32"
-                    );
+                    return declaration.toUintTypeString();
                 }
             }
 

diff --git a/src/ast/postprocessing/builtin_referenced_declaration_normalizer.ts b/src/ast/postprocessing/builtin_referenced_declaration_normalizer.ts
@@ -7,12 +7,8 @@ import { UserDefinedTypeName } from "../implementation/type/user_defined_type_na
 
 type SupportedNode = Identifier | MemberAccess | IdentifierPath | UserDefinedTypeName;
 
-export class BuiltinReferencedDeclarationNormalizer implements ASTNodePostprocessor {
-    process(node: ASTNode, context: ASTContext): void {
-        if (!this.isSupportedNode(node)) {
-            throw new Error(`Supplied node "${node.constructor.name}" is not supported`);
-        }
-
+export class BuiltinReferencedDeclarationNormalizer implements ASTNodePostprocessor<SupportedNode> {
+    process(node: SupportedNode, context: ASTContext): void {
         if (
             node.referencedDeclaration >= 0 &&
             context.locate(node.referencedDeclaration) === undefined
@@ -21,7 +17,7 @@ export class BuiltinReferencedDeclarationNormalizer implements ASTNodePostproces
         }
     }
 
-    private isSupportedNode(node: ASTNode): node is SupportedNode {
+    isSupportedNode(node: ASTNode): node is SupportedNode {
         return (
             node instanceof Identifier ||
             node instanceof MemberAccess ||

diff --git a/src/ast/postprocessing/index.ts b/src/ast/postprocessing/index.ts
@@ -1,3 +1,3 @@
-export * from "./mapping";
 export * from "./builtin_referenced_declaration_normalizer";
+export * from "./list";
 export * from "./structured_documentation_reconstruction";
diff --git a/src/ast/postprocessing/list.ts b/src/ast/postprocessing/list.ts
@@ -0,0 +1,12 @@
+import { ASTNode } from "../ast_node";
+import { ASTNodePostprocessor } from "../ast_reader";
+import { BuiltinReferencedDeclarationNormalizer } from "./builtin_referenced_declaration_normalizer";
+import { StructuredDocumentationReconstructingPostprocessor } from "./structured_documentation_reconstruction";
+
+/**
+ * Note that order here really matters
+ */
+export const DefaultNodePostprocessorList: Array<ASTNodePostprocessor<ASTNode>> = [
+    new BuiltinReferencedDeclarationNormalizer(),
+    new StructuredDocumentationReconstructingPostprocessor()
+];
diff --git a/src/ast/postprocessing/mapping.ts b/src/ast/postprocessing/mapping.ts
diff --git a/src/ast/postprocessing/structured_documentation_reconstruction.ts b/src/ast/postprocessing/structured_documentation_reconstruction.ts
@@ -126,14 +126,12 @@ type SupportedNode =
     | EventDefinition
     | ModifierDefinition;
 
-export class StructuredDocumentationReconstructingPostprocessor implements ASTNodePostprocessor {
+export class StructuredDocumentationReconstructingPostprocessor
+    implements ASTNodePostprocessor<SupportedNode>
+{
     private reconstructor = new StructuredDocumentationReconstructor();
 
-    process(node: ASTNode, context: ASTContext, sources?: Map<string, string>): void {
-        if (!this.isSupportedNode(node)) {
-            return;
-        }
-
+    process(node: SupportedNode, context: ASTContext, sources?: Map<string, string>): void {
         if (node.documentation instanceof StructuredDocumentation || sources === undefined) {
             return;
         }
@@ -160,7 +158,7 @@ export class StructuredDocumentationReconstructingPostprocessor implements ASTNo
         structDocNode.parent = node;
     }
 
-    private isSupportedNode(node: ASTNode): node is SupportedNode {
+    isSupportedNode(node: ASTNode): node is SupportedNode {
         return (
             node instanceof FunctionDefinition ||
             node instanceof ContractDefinition ||

diff --git a/src/ast/writing/ast_mapping.ts b/src/ast/writing/ast_mapping.ts
@@ -1305,7 +1305,7 @@ class SourceUnitWriter extends ASTNodeWriter {
             result.push(...flatten(node.vImportDirectives.map(writeLineFn)), wrap);
         }
 
-        const typeDefs = node.vEnums.concat(node.vStructs);
+        const typeDefs = [...node.vEnums, ...node.vStructs];
 
         if (typeDefs.length > 0) {
             result.push(...flatJoin(typeDefs.map(writeLineFn), wrap), wrap);
@@ -1315,10 +1315,7 @@ class SourceUnitWriter extends ASTNodeWriter {
             result.push(...flatten(node.vVariables.map((n) => [...writeFn(n), ";", wrap])), wrap);
         }
 
-        const otherDefs = (node.vErrors as readonly ASTNode[]).concat(
-            node.vFunctions,
-            node.vContracts
-        );
+        const otherDefs = [...node.vErrors, ...node.vFunctions, ...node.vContracts];
 
         if (otherDefs.length > 0) {
             result.push(...flatJoin(otherDefs.map(writeLineFn), wrap));