@snovon/solast 0.2.0

package/dist/detectors/check-effects-interactions.js

@@ -0,0 +1,783 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckEffectsInteractionsDetector = void 0;
+const ast_1 = require("./_common/ast");
+const RULE_ID = 'check-effects-interactions';
+const PATTERN_EAI = `${RULE_ID}/effect-after-interaction`;
+const PATTERN_CAE = `${RULE_ID}/check-after-effect`;
+const ASSIGN_OPS = new Set([
+    '=', '+=', '-=', '*=', '/=', '%=',
+    '&=', '|=', '^=', '<<=', '>>=', '>>>=',
+]);
+const UNARY_MUTATORS = new Set(['++', '--', 'delete']);
+const LOW_LEVEL_CALL_MEMBERS = new Set([
+    'call', 'delegatecall', 'staticcall', 'send', 'transfer',
+]);
+const BUILTIN_BASE_IDENTIFIERS = new Set([
+    'msg', 'block', 'tx', 'abi', 'super', 'this', 'address', 'payable',
+    'type', 'bytes', 'string', 'keccak256', 'sha256', 'ripemd160', 'ecrecover',
+    'assert', 'require', 'revert', 'gasleft',
+]);
+class CheckEffectsInteractionsDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser'];
+    currentFile = '';
+    typeKinds = {
+        interfaces: new Set(),
+        contracts: new Set(),
+        libraries: new Set(),
+        structs: new Set(),
+        enums: new Set(),
+    };
+    scanAst(ast, file, _sourceText, ctxArg) {
+        this.currentFile = file;
+        const results = [];
+        if (!ast || ast.type !== 'SourceUnit')
+            return results;
+        this.typeKinds = this.collectTypeKinds(ast);
+        const contractsByName = this.collectContractsByName(ast);
+        // SemanticModel adoption (roadmap 3.3 / Slice 3). After the local
+        // per-contract walk, also analyze inherited functions whose AST
+        // lives in a base contract — potentially in another file the per-
+        // contract walk doesn't reach. When undefined the detector falls
+        // back to the pre-Slice-3 in-file-only behaviour.
+        const semantic = ctxArg?.semantic;
+        for (const child of ast.children || []) {
+            if (child?.type !== 'ContractDefinition')
+                continue;
+            if (child.kind === 'interface' || child.kind === 'library')
+                continue;
+            const stateVars = this.collectStateVariables(child, contractsByName);
+            const stateTypes = this.collectStateVarTypes(child, contractsByName);
+            const internalSummaries = this.summarizeInternalFunctions(child, stateVars, stateTypes);
+            const localFnNames = new Set();
+            for (const sub of child.subNodes || []) {
+                if (sub?.type !== 'FunctionDefinition')
+                    continue;
+                if (typeof sub.name === 'string' && sub.name)
+                    localFnNames.add(sub.name);
+                if (!sub.body)
+                    continue;
+                if (sub.isConstructor)
+                    continue;
+                if (sub.kind === 'constructor')
+                    continue;
+                const mutability = String(sub.stateMutability || '').toLowerCase();
+                if (mutability === 'view' || mutability === 'pure')
+                    continue;
+                const findings = this.analyzeFunction(child, sub, stateVars, stateTypes, internalSummaries);
+                results.push(...findings);
+            }
+            // === SemanticModel adoption (Slice 3) ===
+            //
+            // Walk the contract's MRO for inherited externally-callable
+            // FunctionDefinitions and run the same CEI analysis against their
+            // bodies — using the DECLARING contract's state-vars + internal
+            // summaries so cross-MRO writes and helpers resolve correctly.
+            // Findings anchor at the CURRENT contract's definition line (the
+            // surface a caller reaches); instance_key keeps findingIds distinct
+            // when a derived contract inherits multiple CEI-violating
+            // functions on the same anchor line.
+            if (semantic) {
+                const myId = `${file}::${child.name || ''}`;
+                const myInfo = semantic.contracts.get(myId);
+                if (myInfo && myInfo.bases.length > 0) {
+                    const childName = child.name || '<anonymous>';
+                    const anchorLoc = (child?.loc?.start || { line: 1, column: 0 });
+                    for (const inheritedFn of semantic.inheritedFunctions(myId)) {
+                        if (inheritedFn.contractId === myId)
+                            continue;
+                        if (!inheritedFn.name)
+                            continue;
+                        if (localFnNames.has(inheritedFn.name))
+                            continue;
+                        const fnNode = inheritedFn.node;
+                        if (!fnNode)
+                            continue;
+                        if (!fnNode.body)
+                            continue;
+                        if (fnNode.isConstructor)
+                            continue;
+                        if (String(fnNode.kind || '').toLowerCase() === 'constructor')
+                            continue;
+                        const visibility = String(fnNode.visibility || '').toLowerCase();
+                        if (visibility !== 'public' && visibility !== 'external')
+                            continue;
+                        const mutability = String(fnNode.stateMutability || '').toLowerCase();
+                        if (mutability === 'view' || mutability === 'pure')
+                            continue;
+                        const declarer = semantic.contracts.get(inheritedFn.contractId);
+                        if (!declarer || !declarer.node)
+                            continue;
+                        // Use the declaring contract's state-vars + internal-summary
+                        // vocabulary so writes/helpers inside the inherited body
+                        // resolve. `collectStateVariables` walks bases of the
+                        // declarer (with `contractsByName` as the lookup table) —
+                        // here we pass the local map; it will simply skip
+                        // unresolved cross-file bases for the declarer (lenient,
+                        // mirrors pre-Slice-3 behaviour for in-file inheritance).
+                        const declarerStateVars = this.collectStateVariables(declarer.node, contractsByName);
+                        const declarerStateTypes = this.collectStateVarTypes(declarer.node, contractsByName);
+                        const declarerInternals = this.summarizeInternalFunctions(declarer.node, declarerStateVars, declarerStateTypes);
+                        const inheritedFindings = this.analyzeFunction(child, fnNode, declarerStateVars, declarerStateTypes, declarerInternals);
+                        // Patch each inherited finding to anchor at the derived
+                        // contract's def line + carry an instance_key discriminator
+                        // so collisions on (file, line, ruleId) don't lose findings
+                        // in computeFindingId. Same pattern as Slice 2a/2b.
+                        const declarerName = declarer.name || '<unknown>';
+                        for (const f of inheritedFindings) {
+                            f.line = anchorLoc.line;
+                            f.column = anchorLoc.column;
+                            f.sourceLocation = { line: anchorLoc.line, column: anchorLoc.column };
+                            f.instance_key = `${childName}::${inheritedFn.name}`;
+                            f.message =
+                                `Check-effects-interactions violation in inherited function '${inheritedFn.name}' ` +
+                                    `(from ${declarerName}): state mutation occurs after an external interaction, reachable ` +
+                                    `through ${childName} via inheritance.`;
+                        }
+                        results.push(...inheritedFindings);
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    analyzeFunction(contract, fn, stateVars, stateTypes, internalSummaries) {
+        const localVars = this.collectLocals(fn);
+        const localTypes = this.collectLocalTypes(fn);
+        const state = {
+            sawInteraction: false,
+            sawEffect: false,
+            effectAfterInteraction: null,
+            checkAfterEffect: null,
+        };
+        const ctx = { stateVars, stateTypes, localVars, localTypes, internalSummaries };
+        this.walkForCEI(fn.body, state, ctx, false);
+        const findings = [];
+        const fnName = fn.name || (fn.isConstructor ? '<constructor>' : '<anonymous>');
+        if (state.effectAfterInteraction && !this.functionHasReentrancyGuard(fn)) {
+            findings.push(this.makeFinding(contract, fnName, state.effectAfterInteraction.loc, 'effect-after-interaction', `Check-effects-interactions violation in '${fnName}': state mutation occurs after an external interaction.`));
+        }
+        if (state.checkAfterEffect) {
+            findings.push(this.makeFinding(contract, fnName, state.checkAfterEffect.loc, 'check-after-effect', `Check-effects-interactions violation in '${fnName}': state-dependent check occurs after a state effect.`));
+        }
+        return findings;
+    }
+    // Recursive source-ordered walk so interactions and effects are sequenced by
+    // their actual position in the AST — including across nested control flow
+    // such as `if (cond) { external.call(...); state = x; }`, where both the
+    // call and the write live inside the same statement node.
+    walkForCEI(node, state, ctx, effectsGuarded) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'EmitStatement')
+            return;
+        if (node.type === 'IfStatement') {
+            if (node.condition)
+                this.walkForCEI(node.condition, state, ctx, effectsGuarded);
+            const trueBranchGuarded = effectsGuarded || (!!node.trueBody && this.blockEndsWithRevertOrThrow(node.trueBody));
+            const falseBranchGuarded = effectsGuarded || (!!node.falseBody && this.blockEndsWithRevertOrThrow(node.falseBody));
+            if (node.trueBody)
+                this.walkForCEI(node.trueBody, state, ctx, trueBranchGuarded);
+            if (node.falseBody)
+                this.walkForCEI(node.falseBody, state, ctx, falseBranchGuarded);
+            return;
+        }
+        if (node.type === 'VariableDeclarationStatement') {
+            if (node.initialValue)
+                this.walkForCEI(node.initialValue, state, ctx, effectsGuarded);
+            return;
+        }
+        if (node.type === 'FunctionCall') {
+            const directName = this.getDirectCallName(node.expression);
+            if (directName === 'require' || directName === 'assert') {
+                const args = node.arguments || [];
+                const condition = args[0];
+                if (condition &&
+                    this.containsStateReadInCheck(condition, ctx)) {
+                    if (state.sawEffect && !state.checkAfterEffect) {
+                        state.checkAfterEffect = { loc: this.locOf(node) };
+                    }
+                }
+                for (const arg of args) {
+                    this.walkForCEI(arg, state, ctx, effectsGuarded);
+                }
+                return;
+            }
+            if (this.isExternalCallExpression(node, ctx.stateVars, ctx.stateTypes, ctx.localVars, ctx.localTypes)) {
+                for (const arg of node.arguments || []) {
+                    this.walkForCEI(arg, state, ctx, effectsGuarded);
+                }
+                state.sawInteraction = true;
+                return;
+            }
+            if (directName) {
+                const summary = ctx.internalSummaries.get(directName);
+                if (summary?.performsInteraction) {
+                    for (const arg of node.arguments || []) {
+                        this.walkForCEI(arg, state, ctx, effectsGuarded);
+                    }
+                    state.sawInteraction = true;
+                    return;
+                }
+            }
+            for (const child of this.childNodes(node)) {
+                this.walkForCEI(child, state, ctx, effectsGuarded);
+            }
+            return;
+        }
+        if (node.type === 'BinaryOperation' && ASSIGN_OPS.has(node.operator)) {
+            if (this.refersToStateStorage(node.left, ctx.stateVars, ctx.localVars)) {
+                if (node.right)
+                    this.walkForCEI(node.right, state, ctx, effectsGuarded);
+                state.sawEffect = true;
+                if (state.sawInteraction && !state.effectAfterInteraction && !effectsGuarded) {
+                    state.effectAfterInteraction = { loc: this.locOf(node) };
+                }
+                if (node.left)
+                    this.walkForCEI(node.left, state, ctx, effectsGuarded);
+                return;
+            }
+        }
+        if (node.type === 'UnaryOperation' && UNARY_MUTATORS.has(node.operator)) {
+            if (this.refersToStateStorage(node.subExpression, ctx.stateVars, ctx.localVars)) {
+                state.sawEffect = true;
+                if (state.sawInteraction && !state.effectAfterInteraction && !effectsGuarded) {
+                    state.effectAfterInteraction = { loc: this.locOf(node) };
+                }
+                return;
+            }
+        }
+        for (const child of this.childNodes(node)) {
+            this.walkForCEI(child, state, ctx, effectsGuarded);
+        }
+    }
+    isExternalCallExpression(call, stateVars, stateTypes, localVars, localTypes) {
+        let callee = call?.expression;
+        if (callee?.type === 'NameValueExpression')
+            callee = callee.expression;
+        if (callee?.type === 'MemberAccess') {
+            const member = String(callee.memberName || '').toLowerCase();
+            if (LOW_LEVEL_CALL_MEMBERS.has(member))
+                return true;
+            // Treat `base.member(...)` as an external interaction when `base` is a
+            // state variable, OR a parameter / local whose declared type resolves to
+            // an interface, contract, or `address` / `address payable`. Continue to
+            // suppress builtins (`msg`, `block`, ...) and bases whose type is a
+            // local struct, enum, library, mapping, array, or non-address elementary
+            // — those are not external callees. When type information is missing
+            // for a non-builtin base, lean toward flagging: missing CEI detections
+            // are the bug we are fixing here.
+            const baseName = this.simpleIdentifierName(callee.expression);
+            if (baseName) {
+                if (BUILTIN_BASE_IDENTIFIERS.has(baseName))
+                    return false;
+                if (stateVars.has(baseName)) {
+                    const cls = this.classifyBaseType(stateTypes.get(baseName));
+                    if (cls === 'safe')
+                        return false;
+                    return true;
+                }
+                if (localVars.has(baseName)) {
+                    const cls = this.classifyBaseType(localTypes.get(baseName));
+                    if (cls === 'safe')
+                        return false;
+                    return true;
+                }
+            }
+            else {
+                // Inline cast pattern: `IFace(addr).method(...)` or `address(x).method(...)`.
+                // Recognize only when the cast resolves to a contract, interface, or
+                // address-like type — keep unknown casts conservative so they do not
+                // become broad false positives.
+                const baseExpr = callee.expression;
+                if (baseExpr?.type === 'FunctionCall' && Array.isArray(baseExpr.arguments) && baseExpr.arguments.length === 1) {
+                    const cls = this.classifyCastCallee(baseExpr.expression);
+                    if (cls === 'external')
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    classifyCastCallee(expr) {
+        if (!expr || typeof expr !== 'object')
+            return 'unknown';
+        if (expr.type === 'ElementaryTypeName') {
+            const name = String(expr.name || '').toLowerCase();
+            return name === 'address' ? 'external' : 'safe';
+        }
+        if (expr.type === 'UserDefinedTypeName') {
+            return this.classifyBaseType(expr);
+        }
+        if (expr.type === 'Identifier') {
+            const name = String(expr.name || '');
+            if (this.typeKinds.interfaces.has(name))
+                return 'external';
+            if (this.typeKinds.contracts.has(name))
+                return 'external';
+            if (this.typeKinds.libraries.has(name))
+                return 'safe';
+            if (this.typeKinds.structs.has(name))
+                return 'safe';
+            if (this.typeKinds.enums.has(name))
+                return 'safe';
+            if (name === 'address' || name === 'payable')
+                return 'external';
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+    classifyBaseType(typeName) {
+        if (!typeName || typeof typeName !== 'object')
+            return 'unknown';
+        if (typeName.type === 'ElementaryTypeName') {
+            const name = String(typeName.name || '').toLowerCase();
+            return name === 'address' ? 'external' : 'safe';
+        }
+        if (typeName.type === 'UserDefinedTypeName') {
+            const namePath = String(typeName.namePath || '');
+            const head = namePath.split('.')[0];
+            if (this.typeKinds.interfaces.has(head))
+                return 'external';
+            if (this.typeKinds.contracts.has(head))
+                return 'external';
+            if (this.typeKinds.libraries.has(head))
+                return 'safe';
+            if (this.typeKinds.structs.has(head))
+                return 'safe';
+            if (this.typeKinds.enums.has(head))
+                return 'safe';
+            return 'unknown';
+        }
+        if (typeName.type === 'ArrayTypeName' || typeName.type === 'Mapping' || typeName.type === 'FunctionTypeName') {
+            return 'safe';
+        }
+        return 'unknown';
+    }
+    containsStateRead(node, stateVars, localVars) {
+        if (!node || typeof node !== 'object')
+            return false;
+        if (node.type === 'Identifier') {
+            const name = String(node.name || '');
+            if (BUILTIN_BASE_IDENTIFIERS.has(name))
+                return false;
+            if (localVars.has(name))
+                return false;
+            if (stateVars.has(name))
+                return true;
+            return false;
+        }
+        if (node.type === 'IndexAccess') {
+            if (this.containsStateRead(node.base, stateVars, localVars))
+                return true;
+            if (this.containsStateRead(node.index, stateVars, localVars))
+                return true;
+            return false;
+        }
+        if (node.type === 'MemberAccess') {
+            // Recurse into base only; member name itself isn't a free identifier.
+            return this.containsStateRead(node.expression, stateVars, localVars);
+        }
+        for (const child of this.childNodes(node)) {
+            if (this.containsStateRead(child, stateVars, localVars))
+                return true;
+        }
+        return false;
+    }
+    refersToStateStorage(expr, stateVars, localVars) {
+        if (!expr || typeof expr !== 'object')
+            return false;
+        if (expr.type === 'Identifier') {
+            const name = String(expr.name || '');
+            if (localVars.has(name))
+                return false;
+            return stateVars.has(name);
+        }
+        if (expr.type === 'IndexAccess')
+            return this.refersToStateStorage(expr.base, stateVars, localVars);
+        if (expr.type === 'MemberAccess')
+            return this.refersToStateStorage(expr.expression, stateVars, localVars);
+        if (expr.type === 'TupleExpression') {
+            for (const c of expr.components || []) {
+                if (this.refersToStateStorage(c, stateVars, localVars))
+                    return true;
+            }
+        }
+        return false;
+    }
+    blockEndsWithRevertOrThrow(block) {
+        if (!block || typeof block !== 'object')
+            return false;
+        const stmts = block.type === 'Block' ? (block.statements || []) : [block];
+        for (const s of stmts) {
+            if (this.statementIsRevertOrThrow(s))
+                return true;
+        }
+        return false;
+    }
+    statementIsRevertOrThrow(stmt) {
+        if (!stmt || typeof stmt !== 'object')
+            return false;
+        if (stmt.type === 'RevertStatement')
+            return true;
+        if (stmt.type === 'ThrowStatement')
+            return true;
+        if (stmt.type === 'ExpressionStatement') {
+            const expr = stmt.expression;
+            if (expr?.type === 'FunctionCall') {
+                const name = this.getDirectCallName(expr.expression);
+                if (name === 'revert')
+                    return true;
+            }
+        }
+        return false;
+    }
+    summarizeInternalFunctions(contract, stateVars, stateTypes) {
+        const summaries = new Map();
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'FunctionDefinition')
+                continue;
+            if (!sub.body)
+                continue;
+            if (sub.isConstructor)
+                continue;
+            const name = sub.name;
+            if (!name)
+                continue;
+            const localVars = this.collectLocals(sub);
+            const localTypes = this.collectLocalTypes(sub);
+            const performsInteraction = this.bodyContainsExternalCall(sub.body, stateVars, stateTypes, localVars, localTypes);
+            summaries.set(name, { name, performsInteraction });
+        }
+        return summaries;
+    }
+    bodyContainsExternalCall(node, stateVars, stateTypes, localVars, localTypes) {
+        if (!node || typeof node !== 'object')
+            return false;
+        if (node.type === 'FunctionCall' && this.isExternalCallExpression(node, stateVars, stateTypes, localVars, localTypes)) {
+            return true;
+        }
+        for (const child of this.childNodes(node)) {
+            if (this.bodyContainsExternalCall(child, stateVars, stateTypes, localVars, localTypes))
+                return true;
+        }
+        return false;
+    }
+    // Recognize functions that are protected by a reentrancy guard so the
+    // Euler-style effect-after-interaction diagnostic does not flag them as
+    // false positives. Only suppresses the EAI sub-pattern; check-after-effect
+    // remains a structural ordering issue worth reporting even under a guard.
+    functionHasReentrancyGuard(fn) {
+        const modifiers = fn?.modifiers || [];
+        for (const mod of modifiers) {
+            const name = String(mod?.name || '');
+            if (this.isReentrancyGuardModifierName(name))
+                return true;
+        }
+        return this.bodyHasInlineMutexPattern(fn?.body);
+    }
+    isReentrancyGuardModifierName(name) {
+        if (!name)
+            return false;
+        const exact = new Set([
+            'nonReentrant', '_nonReentrant', 'noReentrant',
+            'lock', 'locked', 'mutex',
+        ]);
+        if (exact.has(name))
+            return true;
+        // Narrow substring match limited to clear guard terms — avoids false
+        // suppression on unrelated identifiers while catching custom names like
+        // `noReentrancy`, `withMutex`, etc.
+        const lower = name.toLowerCase();
+        if (lower.includes('reentran'))
+            return true;
+        if (lower.includes('mutex'))
+            return true;
+        return false;
+    }
+    // Detects a simple inline mutex: `require(!<g>, ...)` somewhere in the
+    // top-level body together with both `<g> = true;` and `<g> = false;` writes
+    // to the same identifier. Intentionally conservative — does not try to
+    // prove that the guard is set before / cleared after the external call.
+    bodyHasInlineMutexPattern(body) {
+        if (!body || body.type !== 'Block')
+            return false;
+        const stmts = body.statements || [];
+        const guardNames = new Set();
+        for (const stmt of stmts) {
+            if (stmt?.type !== 'ExpressionStatement')
+                continue;
+            const expr = stmt.expression;
+            if (expr?.type !== 'FunctionCall')
+                continue;
+            if (this.getDirectCallName(expr.expression) !== 'require')
+                continue;
+            const arg0 = expr.arguments?.[0];
+            if (arg0?.type !== 'UnaryOperation' || arg0.operator !== '!')
+                continue;
+            const guardName = this.simpleIdentifierName(arg0.subExpression);
+            if (guardName)
+                guardNames.add(guardName);
+        }
+        if (guardNames.size === 0)
+            return false;
+        for (const guardName of guardNames) {
+            let setTrue = false;
+            let setFalse = false;
+            for (const s of stmts) {
+                if (s?.type !== 'ExpressionStatement')
+                    continue;
+                const e = s.expression;
+                if (e?.type !== 'BinaryOperation' || e.operator !== '=')
+                    continue;
+                if (this.simpleIdentifierName(e.left) !== guardName)
+                    continue;
+                const lit = e.right;
+                if (lit?.type === 'BooleanLiteral') {
+                    if (lit.value === true)
+                        setTrue = true;
+                    else if (lit.value === false)
+                        setFalse = true;
+                }
+            }
+            if (setTrue && setFalse)
+                return true;
+        }
+        return false;
+    }
+    containsStateReadInCheck(node, ctx) {
+        if (!node || typeof node !== 'object')
+            return false;
+        if (node.type === 'FunctionCall') {
+            if (this.isExternalCallExpression(node, ctx.stateVars, ctx.stateTypes, ctx.localVars, ctx.localTypes)) {
+                for (const arg of node.arguments || []) {
+                    if (this.containsStateReadInCheck(arg, ctx))
+                        return true;
+                }
+                return false;
+            }
+        }
+        return this.containsStateRead(node, ctx.stateVars, ctx.localVars);
+    }
+    collectStateVariables(contract, contractsByName, visited = new Set()) {
+        const set = new Set();
+        const contractName = String(contract?.name || '');
+        if (contractName) {
+            if (visited.has(contractName))
+                return set;
+            visited.add(contractName);
+        }
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'StateVariableDeclaration')
+                continue;
+            for (const v of sub.variables || []) {
+                if (v?.name)
+                    set.add(v.name);
+            }
+        }
+        for (const base of contract.baseContracts || []) {
+            const baseName = this.baseContractName(base);
+            if (!baseName)
+                continue;
+            const baseContract = contractsByName.get(baseName);
+            if (!baseContract)
+                continue;
+            for (const name of this.collectStateVariables(baseContract, contractsByName, visited)) {
+                set.add(name);
+            }
+        }
+        return set;
+    }
+    collectStateVarTypes(contract, contractsByName, visited = new Set()) {
+        const map = new Map();
+        const contractName = String(contract?.name || '');
+        if (contractName) {
+            if (visited.has(contractName))
+                return map;
+            visited.add(contractName);
+        }
+        for (const sub of contract.subNodes || []) {
+            if (sub?.type !== 'StateVariableDeclaration')
+                continue;
+            for (const v of sub.variables || []) {
+                if (v?.name)
+                    map.set(v.name, v.typeName);
+            }
+        }
+        for (const base of contract.baseContracts || []) {
+            const baseName = this.baseContractName(base);
+            if (!baseName)
+                continue;
+            const baseContract = contractsByName.get(baseName);
+            if (!baseContract)
+                continue;
+            for (const [name, type] of this.collectStateVarTypes(baseContract, contractsByName, visited)) {
+                if (!map.has(name))
+                    map.set(name, type);
+            }
+        }
+        return map;
+    }
+    collectContractsByName(ast) {
+        const map = new Map();
+        for (const child of ast.children || []) {
+            if (child?.type === 'ContractDefinition' && child.name) {
+                map.set(child.name, child);
+            }
+        }
+        return map;
+    }
+    baseContractName(base) {
+        const namePath = base?.baseName?.namePath;
+        if (namePath)
+            return String(namePath).split('.').pop() || '';
+        const name = base?.baseName?.name;
+        if (name)
+            return String(name).split('.').pop() || '';
+        return '';
+    }
+    collectLocals(fn) {
+        const set = new Set();
+        for (const p of fn.parameters || []) {
+            if (p?.name)
+                set.add(p.name);
+        }
+        for (const p of fn.returnParameters || []) {
+            if (p?.name)
+                set.add(p.name);
+        }
+        this.harvestLocalsRecursive(fn.body, set);
+        return set;
+    }
+    collectLocalTypes(fn) {
+        const map = new Map();
+        for (const p of fn.parameters || []) {
+            if (p?.name)
+                map.set(p.name, p.typeName);
+        }
+        for (const p of fn.returnParameters || []) {
+            if (p?.name)
+                map.set(p.name, p.typeName);
+        }
+        this.harvestLocalTypesRecursive(fn.body, map);
+        return map;
+    }
+    harvestLocalsRecursive(node, set) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'VariableDeclarationStatement') {
+            for (const v of node.variables || []) {
+                if (v?.name)
+                    set.add(v.name);
+            }
+        }
+        for (const child of this.childNodes(node)) {
+            this.harvestLocalsRecursive(child, set);
+        }
+    }
+    harvestLocalTypesRecursive(node, map) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'VariableDeclarationStatement') {
+            for (const v of node.variables || []) {
+                if (v?.name)
+                    map.set(v.name, v.typeName);
+            }
+        }
+        for (const child of this.childNodes(node)) {
+            this.harvestLocalTypesRecursive(child, map);
+        }
+    }
+    collectTypeKinds(ast) {
+        const interfaces = new Set();
+        const contracts = new Set();
+        const libraries = new Set();
+        const structs = new Set();
+        const enums = new Set();
+        const visit = (children) => {
+            for (const node of children || []) {
+                if (!node || typeof node !== 'object')
+                    continue;
+                if (node.type === 'ContractDefinition' && node.name) {
+                    if (node.kind === 'interface')
+                        interfaces.add(node.name);
+                    else if (node.kind === 'library')
+                        libraries.add(node.name);
+                    else if (node.kind === 'contract')
+                        contracts.add(node.name);
+                    if (Array.isArray(node.subNodes))
+                        visit(node.subNodes);
+                }
+                else if (node.type === 'StructDefinition' && node.name) {
+                    structs.add(node.name);
+                }
+                else if (node.type === 'EnumDefinition' && node.name) {
+                    enums.add(node.name);
+                }
+            }
+        };
+        visit(ast.children);
+        return { interfaces, contracts, libraries, structs, enums };
+    }
+    getDirectCallName(expr) {
+        if (!expr || typeof expr !== 'object')
+            return '';
+        if (expr.type === 'Identifier')
+            return String(expr.name || '');
+        return '';
+    }
+    simpleIdentifierName(expr) {
+        if (!expr || typeof expr !== 'object')
+            return '';
+        if (expr.type === 'Identifier')
+            return String(expr.name || '');
+        return '';
+    }
+    locOf(node) {
+        const { line, column } = (0, ast_1.assertLoc)(node);
+        return { line, column };
+    }
+    childNodes(node) {
+        const out = [];
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'loc' || key === 'range' || key === 'typeName')
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (item && typeof item === 'object')
+                        out.push(item);
+                }
+            }
+            else if (value && typeof value === 'object') {
+                out.push(value);
+            }
+        }
+        return out;
+    }
+    makeFinding(contract, functionName, loc, sub, message) {
+        const contractName = contract?.name || '';
+        const pattern = sub === 'effect-after-interaction' ? PATTERN_EAI : PATTERN_CAE;
+        return {
+            file: this.currentFile,
+            contract: contractName,
+            'function': functionName,
+            line: loc.line,
+            column: loc.column,
+            pattern,
+            confidence: 'high',
+            ruleId: RULE_ID,
+            severity: 'warning',
+            message,
+            contractName,
+            functionName,
+            sourceLocation: { line: loc.line, column: loc.column },
+            trace: sub,
+            findingId: '',
+            contractHash: '',
+        };
+    }
+}
+exports.CheckEffectsInteractionsDetector = CheckEffectsInteractionsDetector;
+//# sourceMappingURL=check-effects-interactions.js.map