recon-generate 0.0.6 → 0.0.8

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { ASTNode, ContractDefinition, Assignment, FunctionCall, FunctionDefinition, VariableDeclaration } from 'solc-typed-ast';
+import { ASTNode, ContractDefinition, Assignment, FunctionCall, FunctionDefinition, VariableDeclaration, EventDefinition, ErrorDefinition } from 'solc-typed-ast';
 import { CallType } from './types';
 export declare function fileExists(p: string): Promise<boolean>;
 export declare function getFoundryConfigPath(workspaceRoot: string, override?: string): string;
@@ -29,3 +29,13 @@ export declare function toSource(node: ASTNode, version?: string): string;
 export declare function getCallType(fnCall: FunctionCall): CallType;
 export declare const getFunctionName: (fnDef: FunctionDefinition) => string;
 export declare const signatureEquals: (a: FunctionDefinition, b: FunctionDefinition) => boolean;
+export declare function getSignature(definition: FunctionDefinition | EventDefinition | ErrorDefinition): string;
+export declare function getEnclosingContract(node: ASTNode): ContractDefinition | undefined;
+export declare function resolveOverride(root: ContractDefinition, signature: string): FunctionDefinition | undefined;
+export declare function idToContract(root: ContractDefinition, id: number): ContractDefinition | undefined;
+export declare function forwardLinearization(root: ContractDefinition): ContractDefinition[];
+/**
+ * Resolve the `super` call according to Solidity's C3 linearisation of the root
+ * contract. `current` is the contract whose code contains the `super` call.
+ */
+export declare function resolveSuper(root: ContractDefinition, current: ContractDefinition, signature: string): FunctionDefinition | undefined;

package/dist/utils.js

@@ -58,6 +58,12 @@ exports.getDeepRef = getDeepRef;
 exports.getDefinitions = getDefinitions;
 exports.toSource = toSource;
 exports.getCallType = getCallType;
+exports.getSignature = getSignature;
+exports.getEnclosingContract = getEnclosingContract;
+exports.resolveOverride = resolveOverride;
+exports.idToContract = idToContract;
+exports.forwardLinearization = forwardLinearization;
+exports.resolveSuper = resolveSuper;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const solc_typed_ast_1 = require("solc-typed-ast");
@@ -284,11 +290,27 @@ function getDeepRef(node) {
     }
 }
 function getDefinitions(contract, kind, inclusion = true) {
-    let defs = inclusion ? contract[kind] : [];
-    for (const child of contract.vLinearizedBaseContracts.filter((x) => x !== contract)) {
-        defs = getDefinitions(child, kind).concat(defs.filter((x) => !getDefinitions(child, kind).includes(x)));
-    }
-    return defs;
+    const visited = new Set();
+    const gather = (c) => {
+        if (visited.has(c)) {
+            return [];
+        }
+        visited.add(c);
+        const own = inclusion ? c[kind] : [];
+        const defs = [...(own || [])];
+        for (const base of c.vLinearizedBaseContracts) {
+            if (base === c) {
+                continue;
+            }
+            for (const def of gather(base)) {
+                if (!defs.includes(def)) {
+                    defs.push(def);
+                }
+            }
+        }
+        return defs;
+    };
+    return gather(contract);
 }
 function toSource(node, version) {
     const formatter = new solc_typed_ast_1.PrettyFormatter(4, 0);
@@ -333,3 +355,84 @@ const signatureEquals = (a, b) => {
     return a.stateMutability === b.stateMutability;
 };
 exports.signatureEquals = signatureEquals;
+function getSignature(definition) {
+    let name;
+    if (definition instanceof solc_typed_ast_1.FunctionDefinition) {
+        if (definition.kind === solc_typed_ast_1.FunctionKind.Constructor) {
+            name = 'constructor';
+        }
+        else if (definition.kind === solc_typed_ast_1.FunctionKind.Fallback) {
+            name = 'fallback';
+        }
+        else if (definition.kind === solc_typed_ast_1.FunctionKind.Receive) {
+            name = 'receive';
+        }
+        else {
+            name = definition.name;
+        }
+    }
+    else {
+        name = definition.name;
+    }
+    const paramTypes = definition.vParameters.vParameters.map(param => param.typeString).join(',');
+    return `${name}(${paramTypes})`;
+}
+function getEnclosingContract(node) {
+    let cur = node;
+    while (cur) {
+        if (cur instanceof solc_typed_ast_1.FunctionDefinition && cur.vScope instanceof solc_typed_ast_1.ContractDefinition) {
+            return cur.vScope;
+        }
+        cur = cur.parent;
+    }
+    return undefined;
+}
+function resolveOverride(root, signature) {
+    for (const ctr of forwardLinearization(root)) {
+        const match = ctr.vFunctions.find(fn => getSignature(fn) === signature);
+        if (match)
+            return match;
+    }
+    return undefined;
+}
+function idToContract(root, id) {
+    try {
+        return root.requiredContext.locate(id);
+    }
+    catch {
+        return undefined;
+    }
+}
+// Build forward (source-order) linearized list: root, then direct bases left->right, then their bases recursively without duplicates.
+function forwardLinearization(root) {
+    // Solidity compiler provides the C3 linearized order in `linearizedBaseContracts`.
+    // We rely on that order directly; it already starts with `root` and follows the
+    // resolution order used for `super`.
+    const ids = root.linearizedBaseContracts;
+    const contracts = [];
+    for (const id of ids) {
+        const ctr = idToContract(root, id);
+        if (ctr)
+            contracts.push(ctr);
+    }
+    return contracts;
+}
+/**
+ * Resolve the `super` call according to Solidity's C3 linearisation of the root
+ * contract. `current` is the contract whose code contains the `super` call.
+ */
+function resolveSuper(root, current, signature) {
+    // Linearised list of contract IDs for `root` (e.g. [D, B, C, A])
+    const linearContracts = forwardLinearization(root);
+    // Find index of the current contract
+    const idx = linearContracts.findIndex(c => c.id === current.id);
+    if (idx === -1)
+        return undefined;
+    // Search forward for first contract implementing the function
+    for (let i = idx + 1; i < linearContracts.length; i++) {
+        const cand = linearContracts[i].vFunctions.find(fn => getSignature(fn) === signature);
+        if (cand)
+            return cand;
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "recon-generate",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "CLI to scaffold Recon fuzzing suite inside Foundry projects",
   "main": "dist/index.js",
   "bin": {