circle-ir 3.9.7 → 3.9.8

package/dist/analysis/passes/deep-inheritance-pass.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pass #29: deep-inheritance (CWE-1086, category: architecture)
+ *
+ * Detects class inheritance chains deeper than the configured threshold
+ * (default: 5). Deep inheritance hierarchies increase coupling, make code
+ * harder to understand, and indicate a design smell (violation of composition
+ * over inheritance).
+ *
+ * Detection strategy:
+ *   1. Build a parentMap: className → parentName from `ir.types[*].extends`.
+ *   2. For each class with a known `start_line`, walk up the parentMap
+ *      counting depth. Stop at depth 20 to defend against cycles.
+ *   3. If depth > THRESHOLD, emit a finding at the class `start_line`.
+ *
+ * Languages: Java, JavaScript/TypeScript, Python. Rust/Bash do not have
+ * class inheritance — skipped.
+ */
+import type { AnalysisPass, PassContext } from '../../graph/analysis-pass.js';
+export interface DeepInheritanceResult {
+    deepClasses: Array<{
+        className: string;
+        depth: number;
+        line: number;
+    }>;
+}
+export declare class DeepInheritancePass implements AnalysisPass<DeepInheritanceResult> {
+    readonly name = "deep-inheritance";
+    readonly category: "architecture";
+    run(ctx: PassContext): DeepInheritanceResult;
+}

package/dist/analysis/passes/deep-inheritance-pass.js

@@ -0,0 +1,82 @@
+/**
+ * Pass #29: deep-inheritance (CWE-1086, category: architecture)
+ *
+ * Detects class inheritance chains deeper than the configured threshold
+ * (default: 5). Deep inheritance hierarchies increase coupling, make code
+ * harder to understand, and indicate a design smell (violation of composition
+ * over inheritance).
+ *
+ * Detection strategy:
+ *   1. Build a parentMap: className → parentName from `ir.types[*].extends`.
+ *   2. For each class with a known `start_line`, walk up the parentMap
+ *      counting depth. Stop at depth 20 to defend against cycles.
+ *   3. If depth > THRESHOLD, emit a finding at the class `start_line`.
+ *
+ * Languages: Java, JavaScript/TypeScript, Python. Rust/Bash do not have
+ * class inheritance — skipped.
+ */
+const DEPTH_THRESHOLD = 5;
+const CYCLE_GUARD = 20;
+export class DeepInheritancePass {
+    name = 'deep-inheritance';
+    category = 'architecture';
+    run(ctx) {
+        const { graph, language } = ctx;
+        if (language === 'rust' || language === 'bash') {
+            return { deepClasses: [] };
+        }
+        const file = graph.ir.meta.file;
+        const types = graph.ir.types;
+        if (types.length === 0)
+            return { deepClasses: [] };
+        // Build parentMap: class name → parent class name
+        const parentMap = new Map();
+        for (const typeInfo of types) {
+            if (typeInfo.extends) {
+                // Strip generic parameters (e.g., "BaseRepo<User>" → "BaseRepo")
+                const parentName = typeInfo.extends.replace(/<.*>/, '').trim();
+                if (parentName) {
+                    parentMap.set(typeInfo.name, parentName);
+                }
+            }
+        }
+        const deepClasses = [];
+        for (const typeInfo of types) {
+            if (typeInfo.kind !== 'class')
+                continue;
+            if (typeInfo.start_line <= 0)
+                continue;
+            // Walk up the inheritance chain
+            let depth = 0;
+            let current = parentMap.get(typeInfo.name);
+            const visited = new Set([typeInfo.name]);
+            while (current !== undefined && depth < CYCLE_GUARD) {
+                depth++;
+                if (visited.has(current))
+                    break; // cycle guard
+                visited.add(current);
+                current = parentMap.get(current);
+            }
+            if (depth > DEPTH_THRESHOLD) {
+                deepClasses.push({ className: typeInfo.name, depth, line: typeInfo.start_line });
+                ctx.addFinding({
+                    id: `deep-inheritance-${file}-${typeInfo.start_line}`,
+                    pass: this.name,
+                    category: this.category,
+                    rule_id: this.name,
+                    cwe: 'CWE-1086',
+                    severity: 'low',
+                    level: 'warning',
+                    message: `Deep inheritance: class \`${typeInfo.name}\` has inheritance depth ${depth} (threshold: ${DEPTH_THRESHOLD})`,
+                    file,
+                    line: typeInfo.start_line,
+                    fix: `Refactor to prefer composition over inheritance. ` +
+                        `Consider extracting shared behaviour into interfaces or mixins.`,
+                    evidence: { depth, threshold: DEPTH_THRESHOLD },
+                });
+            }
+        }
+        return { deepClasses };
+    }
+}
+//# sourceMappingURL=deep-inheritance-pass.js.map

package/dist/analysis/passes/deep-inheritance-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-inheritance-pass.js","sourceRoot":"","sources":["../../../src/analysis/passes/deep-inheritance-pass.ts"],"names":[],"mappings":"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"}

package/dist/analysis/passes/infinite-loop-pass.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pass #28: infinite-loop (CWE-835, category: reliability)
+ *
+ * Detects loops with no reachable exit edge — i.e., loops that can run
+ * forever because every execution path through the loop body leads back to
+ * the loop header without a break, return, throw, or continue-to-outer.
+ *
+ * Detection strategy:
+ *   1. Identify loop headers: back-edge targets in the CFG (`edge.type === 'back'`).
+ *   2. For each loop, collect the loop body blocks via BFS from the header,
+ *      stopping at back-edge sources (the "tail" blocks).
+ *   3. Check whether any block in the body has an outgoing edge that exits
+ *      the loop (target not in body set and not back to header).
+ *   4. As a text-level fallback, scan source lines in the loop body for
+ *      `return`, `throw`/`raise`, `break`, `System.exit` keywords.
+ *   5. Emit a finding at the loop header's start_line if no exit is found.
+ *
+ * Languages: Java, JavaScript, TypeScript, Python, Rust. Skip Bash.
+ */
+import type { AnalysisPass, PassContext } from '../../graph/analysis-pass.js';
+export interface InfiniteLoopResult {
+    potentialInfiniteLoops: Array<{
+        headerLine: number;
+        bodyEndLine: number;
+    }>;
+}
+export declare class InfiniteLoopPass implements AnalysisPass<InfiniteLoopResult> {
+    readonly name = "infinite-loop";
+    readonly category: "reliability";
+    run(ctx: PassContext): InfiniteLoopResult;
+}

package/dist/analysis/passes/infinite-loop-pass.js

@@ -0,0 +1,126 @@
+/**
+ * Pass #28: infinite-loop (CWE-835, category: reliability)
+ *
+ * Detects loops with no reachable exit edge — i.e., loops that can run
+ * forever because every execution path through the loop body leads back to
+ * the loop header without a break, return, throw, or continue-to-outer.
+ *
+ * Detection strategy:
+ *   1. Identify loop headers: back-edge targets in the CFG (`edge.type === 'back'`).
+ *   2. For each loop, collect the loop body blocks via BFS from the header,
+ *      stopping at back-edge sources (the "tail" blocks).
+ *   3. Check whether any block in the body has an outgoing edge that exits
+ *      the loop (target not in body set and not back to header).
+ *   4. As a text-level fallback, scan source lines in the loop body for
+ *      `return`, `throw`/`raise`, `break`, `System.exit` keywords.
+ *   5. Emit a finding at the loop header's start_line if no exit is found.
+ *
+ * Languages: Java, JavaScript, TypeScript, Python, Rust. Skip Bash.
+ */
+/** Exit keywords to scan for as a text-level fallback. */
+const EXIT_KEYWORDS = /\b(return|throw|raise|break|System\.exit|process\.exit|os\._exit|exit!\()\b/;
+export class InfiniteLoopPass {
+    name = 'infinite-loop';
+    category = 'reliability';
+    run(ctx) {
+        const { graph, code, language } = ctx;
+        if (language === 'bash') {
+            return { potentialInfiniteLoops: [] };
+        }
+        const { blocks, edges } = graph.ir.cfg;
+        if (blocks.length === 0)
+            return { potentialInfiniteLoops: [] };
+        const file = graph.ir.meta.file;
+        const codeLines = code.split('\n');
+        // Build adjacency maps
+        const outgoing = new Map();
+        for (const edge of edges) {
+            const list = outgoing.get(edge.from) ?? [];
+            list.push({ to: edge.to, type: edge.type });
+            outgoing.set(edge.from, list);
+        }
+        // Find back-edges: each back-edge defines a loop
+        const backEdges = edges.filter(e => e.type === 'back');
+        const potentialInfiniteLoops = [];
+        const reportedHeaders = new Set();
+        for (const backEdge of backEdges) {
+            const headerId = backEdge.to;
+            const tailId = backEdge.from;
+            const header = graph.blockById.get(headerId);
+            const tail = graph.blockById.get(tailId);
+            if (!header || !tail)
+                continue;
+            // Deduplicate: one finding per header
+            if (reportedHeaders.has(headerId))
+                continue;
+            // Collect loop body blocks via BFS from header, stopping at tail
+            const bodyIds = new Set();
+            const queue = [headerId];
+            bodyIds.add(headerId);
+            while (queue.length > 0) {
+                const cur = queue.shift();
+                for (const { to, type } of outgoing.get(cur) ?? []) {
+                    // Don't follow back edges (stay inside the loop)
+                    if (type === 'back')
+                        continue;
+                    if (!bodyIds.has(to)) {
+                        bodyIds.add(to);
+                        queue.push(to);
+                    }
+                }
+                // Stop expanding from tail (the back-edge source)
+                if (cur === tailId)
+                    break;
+            }
+            // Check for any exit edge: an edge from a body block to a non-body block
+            let hasExit = false;
+            for (const bodyId of bodyIds) {
+                for (const { to, type } of outgoing.get(bodyId) ?? []) {
+                    if (type === 'back')
+                        continue;
+                    if (!bodyIds.has(to)) {
+                        hasExit = true;
+                        break;
+                    }
+                }
+                if (hasExit)
+                    break;
+            }
+            if (hasExit)
+                continue;
+            // Text-level fallback: scan source lines for exit keywords
+            const bodyStart = header.start_line;
+            const bodyEnd = tail.end_line;
+            let hasKeywordExit = false;
+            for (let ln = bodyStart; ln <= bodyEnd && ln <= codeLines.length; ln++) {
+                if (EXIT_KEYWORDS.test(codeLines[ln - 1] ?? '')) {
+                    hasKeywordExit = true;
+                    break;
+                }
+            }
+            if (hasKeywordExit)
+                continue;
+            reportedHeaders.add(headerId);
+            potentialInfiniteLoops.push({ headerLine: header.start_line, bodyEndLine: bodyEnd });
+            const loc = bodyStart === bodyEnd
+                ? `line ${bodyStart}`
+                : `lines ${bodyStart}–${bodyEnd}`;
+            ctx.addFinding({
+                id: `infinite-loop-${file}-${header.start_line}`,
+                pass: this.name,
+                category: this.category,
+                rule_id: this.name,
+                cwe: 'CWE-835',
+                severity: 'medium',
+                level: 'warning',
+                message: `Potential infinite loop: no reachable break, return, or throw found in loop body (${loc})`,
+                file,
+                line: header.start_line,
+                end_line: bodyEnd > header.start_line ? bodyEnd : undefined,
+                fix: 'Ensure the loop has a reachable exit condition (break, return, or throw) on all paths',
+            });
+        }
+        return { potentialInfiniteLoops };
+    }
+}
+//# sourceMappingURL=infinite-loop-pass.js.map

package/dist/analysis/passes/infinite-loop-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infinite-loop-pass.js","sourceRoot":"","sources":["../../../src/analysis/passes/infinite-loop-pass.ts"],"names":[],"mappings":"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"}

package/dist/analysis/passes/react-inline-jsx-pass.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pass #33: react-inline-jsx (category: performance)
+ *
+ * Detects inline object literals or arrow functions passed as JSX props.
+ * These create a new reference on every render, defeating React.memo /
+ * shouldComponentUpdate optimisations and causing unnecessary re-renders.
+ *
+ * Detection strategy:
+ *   1. Only runs on JavaScript/TypeScript files that appear to contain JSX
+ *      (quick check: source contains a `<UpperCase` JSX component pattern).
+ *   2. Scans each source line for:
+ *      a. Inline object prop:  propName={{   (double-brace)
+ *      b. Inline arrow prop:   propName={(...) =>   or   propName={identifier =>
+ *      c. Inline function prop: propName={function(
+ *   3. Skips:
+ *      - `style={{` — idiomatic and near-impossible to hoist statically
+ *      - `key=` — must be inline
+ *      - `data-*` attribute names
+ *      - Lines that are comments
+ *   4. Emits one finding per matched line.
+ *
+ * Languages: JavaScript and TypeScript only.
+ */
+import type { AnalysisPass, PassContext } from '../../graph/analysis-pass.js';
+export interface ReactInlineJsxResult {
+    inlineProps: Array<{
+        line: number;
+        propName: string;
+        kind: 'object' | 'arrow' | 'function';
+    }>;
+}
+export declare class ReactInlineJsxPass implements AnalysisPass<ReactInlineJsxResult> {
+    readonly name = "react-inline-jsx";
+    readonly category: "performance";
+    run(ctx: PassContext): ReactInlineJsxResult;
+}

package/dist/analysis/passes/react-inline-jsx-pass.js

@@ -0,0 +1,140 @@
+/**
+ * Pass #33: react-inline-jsx (category: performance)
+ *
+ * Detects inline object literals or arrow functions passed as JSX props.
+ * These create a new reference on every render, defeating React.memo /
+ * shouldComponentUpdate optimisations and causing unnecessary re-renders.
+ *
+ * Detection strategy:
+ *   1. Only runs on JavaScript/TypeScript files that appear to contain JSX
+ *      (quick check: source contains a `<UpperCase` JSX component pattern).
+ *   2. Scans each source line for:
+ *      a. Inline object prop:  propName={{   (double-brace)
+ *      b. Inline arrow prop:   propName={(...) =>   or   propName={identifier =>
+ *      c. Inline function prop: propName={function(
+ *   3. Skips:
+ *      - `style={{` — idiomatic and near-impossible to hoist statically
+ *      - `key=` — must be inline
+ *      - `data-*` attribute names
+ *      - Lines that are comments
+ *   4. Emits one finding per matched line.
+ *
+ * Languages: JavaScript and TypeScript only.
+ */
+/** Quick heuristic: does the file contain any JSX component usage? */
+const JSX_COMPONENT_RE = /<[A-Z][A-Za-z0-9]*/;
+/** Inline object prop: propName={{  (but NOT style={{ ) */
+const INLINE_OBJECT_RE = /\s([A-Za-z][A-Za-z0-9_]*)=\{\{/g;
+/** Inline arrow function prop: propName={(...) =>  or  propName={x => */
+const INLINE_ARROW_RE = /\s([A-Za-z][A-Za-z0-9_]*)=\{(?:\(|[A-Za-z_$]).*?=>/g;
+/** Inline function expression prop: propName={function( */
+const INLINE_FUNCTION_RE = /\s([A-Za-z][A-Za-z0-9_]*)=\{function\s*\(/g;
+/** Props to always skip regardless of value shape. */
+const SKIP_PROPS = new Set(['style', 'key', 'ref', 'className', 'id']);
+export class ReactInlineJsxPass {
+    name = 'react-inline-jsx';
+    category = 'performance';
+    run(ctx) {
+        const { graph, code, language } = ctx;
+        if (language !== 'javascript' && language !== 'typescript') {
+            return { inlineProps: [] };
+        }
+        // Quick file-level JSX check
+        if (!JSX_COMPONENT_RE.test(code)) {
+            return { inlineProps: [] };
+        }
+        const file = graph.ir.meta.file;
+        const codeLines = code.split('\n');
+        const inlineProps = [];
+        for (let i = 0; i < codeLines.length; i++) {
+            const lineText = codeLines[i];
+            const ln = i + 1;
+            // Skip comment lines
+            const trimmed = lineText.trimStart();
+            if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) {
+                continue;
+            }
+            // --- Inline object prop: propName={{ ---
+            INLINE_OBJECT_RE.lastIndex = 0;
+            let m;
+            while ((m = INLINE_OBJECT_RE.exec(lineText)) !== null) {
+                const propName = m[1];
+                if (SKIP_PROPS.has(propName))
+                    continue;
+                if (propName.startsWith('data-'))
+                    continue; // data-* attributes
+                inlineProps.push({ line: ln, propName, kind: 'object' });
+                ctx.addFinding({
+                    id: `react-inline-jsx-obj-${file}-${ln}`,
+                    pass: this.name,
+                    category: this.category,
+                    rule_id: this.name,
+                    cwe: undefined,
+                    severity: 'low',
+                    level: 'note',
+                    message: `Inline object in JSX prop \`${propName}\` creates a new reference on every render, ` +
+                        `defeating memoization`,
+                    file,
+                    line: ln,
+                    snippet: lineText.trim(),
+                    fix: `Extract the object literal into a \`useMemo\` hook or a module-level constant, ` +
+                        `then pass the reference: \`${propName}={myConstObject}\`.`,
+                });
+            }
+            // --- Inline arrow function prop: propName={(...) => or propName={x => ---
+            INLINE_ARROW_RE.lastIndex = 0;
+            while ((m = INLINE_ARROW_RE.exec(lineText)) !== null) {
+                const propName = m[1];
+                if (SKIP_PROPS.has(propName))
+                    continue;
+                if (propName.startsWith('data'))
+                    continue;
+                inlineProps.push({ line: ln, propName, kind: 'arrow' });
+                ctx.addFinding({
+                    id: `react-inline-jsx-arrow-${file}-${ln}`,
+                    pass: this.name,
+                    category: this.category,
+                    rule_id: this.name,
+                    cwe: undefined,
+                    severity: 'low',
+                    level: 'note',
+                    message: `Inline arrow function in JSX prop \`${propName}\` creates a new function reference on every render, ` +
+                        `defeating memoization`,
+                    file,
+                    line: ln,
+                    snippet: lineText.trim(),
+                    fix: `Wrap the handler with \`useCallback\` or define it outside the component: ` +
+                        `\`const handle${propName.charAt(0).toUpperCase()}${propName.slice(1)} = useCallback(...)\`.`,
+                });
+            }
+            // --- Inline function expression prop: propName={function( ---
+            INLINE_FUNCTION_RE.lastIndex = 0;
+            while ((m = INLINE_FUNCTION_RE.exec(lineText)) !== null) {
+                const propName = m[1];
+                if (SKIP_PROPS.has(propName))
+                    continue;
+                if (propName.startsWith('data'))
+                    continue;
+                inlineProps.push({ line: ln, propName, kind: 'function' });
+                ctx.addFinding({
+                    id: `react-inline-jsx-fn-${file}-${ln}`,
+                    pass: this.name,
+                    category: this.category,
+                    rule_id: this.name,
+                    cwe: undefined,
+                    severity: 'low',
+                    level: 'note',
+                    message: `Inline function expression in JSX prop \`${propName}\` creates a new function reference on every render, ` +
+                        `defeating memoization`,
+                    file,
+                    line: ln,
+                    snippet: lineText.trim(),
+                    fix: `Wrap the handler with \`useCallback\` or define it outside the component: ` +
+                        `\`const handle${propName.charAt(0).toUpperCase()}${propName.slice(1)} = useCallback(...)\`.`,
+                });
+            }
+        }
+        return { inlineProps };
+    }
+}
+//# sourceMappingURL=react-inline-jsx-pass.js.map

package/dist/analysis/passes/react-inline-jsx-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-inline-jsx-pass.js","sourceRoot":"","sources":["../../../src/analysis/passes/react-inline-jsx-pass.ts"],"names":[],"mappings":"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"}

package/dist/analysis/passes/redundant-loop-pass.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pass #30: redundant-loop-computation (CWE-1050, category: performance)
+ *
+ * Detects loop-invariant expressions that are recomputed on every iteration.
+ * The most common and highest-signal patterns:
+ *   - `.length` / `.size()` / `.count()` on a variable not modified in the loop
+ *   - `Object.keys(x)` / `Object.values(x)` / `Object.entries(x)` on invariant `x`
+ *   - Pure math: `Math.sqrt(x)`, `Math.pow(x, n)`, `Math.abs(x)` on invariant args
+ *
+ * Detection strategy:
+ *   1. Identify loop bodies via `graph.loopBodies()` (CFG back-edge derived).
+ *   2. Build `modifiedVars`: DFG defs whose line falls inside the loop range.
+ *   3. Scan source lines for the invariant patterns.
+ *   4. If the receiver/argument variable is NOT in `modifiedVars`, emit a finding.
+ *
+ * Languages: JavaScript/TypeScript, Java, Python, Rust. Bash — skipped.
+ */
+import type { AnalysisPass, PassContext } from '../../graph/analysis-pass.js';
+export interface RedundantLoopResult {
+    invariants: Array<{
+        line: number;
+        expression: string;
+        variable: string;
+    }>;
+}
+export declare class RedundantLoopPass implements AnalysisPass<RedundantLoopResult> {
+    readonly name = "redundant-loop-computation";
+    readonly category: "performance";
+    run(ctx: PassContext): RedundantLoopResult;
+}

package/dist/analysis/passes/redundant-loop-pass.js

@@ -0,0 +1,146 @@
+/**
+ * Pass #30: redundant-loop-computation (CWE-1050, category: performance)
+ *
+ * Detects loop-invariant expressions that are recomputed on every iteration.
+ * The most common and highest-signal patterns:
+ *   - `.length` / `.size()` / `.count()` on a variable not modified in the loop
+ *   - `Object.keys(x)` / `Object.values(x)` / `Object.entries(x)` on invariant `x`
+ *   - Pure math: `Math.sqrt(x)`, `Math.pow(x, n)`, `Math.abs(x)` on invariant args
+ *
+ * Detection strategy:
+ *   1. Identify loop bodies via `graph.loopBodies()` (CFG back-edge derived).
+ *   2. Build `modifiedVars`: DFG defs whose line falls inside the loop range.
+ *   3. Scan source lines for the invariant patterns.
+ *   4. If the receiver/argument variable is NOT in `modifiedVars`, emit a finding.
+ *
+ * Languages: JavaScript/TypeScript, Java, Python, Rust. Bash — skipped.
+ */
+// Match:  varName.length  or  varName.size()  or  varName.count()
+const LENGTH_PATTERN = /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\.\s*(?:length|size\(\)|count\(\))/g;
+// Match:  Object.keys(varName)  Object.values(varName)  Object.entries(varName)
+const OBJECT_STATIC_PATTERN = /\bObject\s*\.\s*(?:keys|values|entries)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\)/g;
+// Match:  Math.sqrt(varName)  Math.pow(varName  Math.abs(varName)  Math.floor(varName)  Math.ceil(varName)
+const MATH_PATTERN = /\bMath\s*\.\s*(?:sqrt|pow|abs|floor|ceil|round|log|log2|log10)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*[,)]/g;
+export class RedundantLoopPass {
+    name = 'redundant-loop-computation';
+    category = 'performance';
+    run(ctx) {
+        const { graph, code, language } = ctx;
+        if (language === 'bash') {
+            return { invariants: [] };
+        }
+        const file = graph.ir.meta.file;
+        const codeLines = code.split('\n');
+        const loops = graph.loopBodies();
+        if (loops.length === 0)
+            return { invariants: [] };
+        const invariants = [];
+        const reported = new Set(); // deduplicate by line+expression
+        for (const loop of loops) {
+            const { start_line, end_line } = loop;
+            // Collect variables modified (written) inside the loop body
+            const modifiedVars = new Set();
+            for (const def of graph.ir.dfg.defs) {
+                if (def.line >= start_line && def.line <= end_line) {
+                    modifiedVars.add(def.variable);
+                }
+            }
+            // Scan each line in the loop body for invariant patterns
+            for (let ln = start_line; ln <= end_line && ln <= codeLines.length; ln++) {
+                const lineText = codeLines[ln - 1] ?? '';
+                // Skip blank lines
+                if (lineText.trim() === '')
+                    continue;
+                // --- .length / .size() / .count() ---
+                LENGTH_PATTERN.lastIndex = 0;
+                let m;
+                while ((m = LENGTH_PATTERN.exec(lineText)) !== null) {
+                    const varName = m[1];
+                    if (modifiedVars.has(varName))
+                        continue;
+                    // Skip if used in a for-loop initialisation line (e.g., for (let i = 0; i < arr.length; i++))
+                    // — the loop header itself scanning is expected; flag it only inside the body
+                    const expr = m[0];
+                    const key = `${ln}-${expr}`;
+                    if (reported.has(key))
+                        continue;
+                    reported.add(key);
+                    invariants.push({ line: ln, expression: expr, variable: varName });
+                    ctx.addFinding({
+                        id: `redundant-loop-computation-${file}-${ln}`,
+                        pass: this.name,
+                        category: this.category,
+                        rule_id: this.name,
+                        cwe: 'CWE-1050',
+                        severity: 'low',
+                        level: 'note',
+                        message: `Loop-invariant computation: \`${expr}\` is recomputed on every iteration; hoist outside loop`,
+                        file,
+                        line: ln,
+                        snippet: lineText.trim(),
+                        fix: `Compute \`${expr}\` once before the loop and use the cached value inside.`,
+                        evidence: { variable: varName, loop_start: start_line, loop_end: end_line },
+                    });
+                }
+                // --- Object.keys/values/entries(x) ---
+                OBJECT_STATIC_PATTERN.lastIndex = 0;
+                while ((m = OBJECT_STATIC_PATTERN.exec(lineText)) !== null) {
+                    const varName = m[1];
+                    if (modifiedVars.has(varName))
+                        continue;
+                    const expr = m[0];
+                    const key = `${ln}-${expr}`;
+                    if (reported.has(key))
+                        continue;
+                    reported.add(key);
+                    invariants.push({ line: ln, expression: expr, variable: varName });
+                    ctx.addFinding({
+                        id: `redundant-loop-computation-${file}-${ln}-obj`,
+                        pass: this.name,
+                        category: this.category,
+                        rule_id: this.name,
+                        cwe: 'CWE-1050',
+                        severity: 'low',
+                        level: 'note',
+                        message: `Loop-invariant computation: \`${expr}\` allocates a new array on every iteration; hoist outside loop`,
+                        file,
+                        line: ln,
+                        snippet: lineText.trim(),
+                        fix: `Compute \`${expr}\` once before the loop.`,
+                        evidence: { variable: varName, loop_start: start_line, loop_end: end_line },
+                    });
+                }
+                // --- Math.*(x) ---
+                MATH_PATTERN.lastIndex = 0;
+                while ((m = MATH_PATTERN.exec(lineText)) !== null) {
+                    const varName = m[1];
+                    if (modifiedVars.has(varName))
+                        continue;
+                    const expr = m[0].replace(/[,)]?\s*$/, ')');
+                    const key = `${ln}-${expr}`;
+                    if (reported.has(key))
+                        continue;
+                    reported.add(key);
+                    invariants.push({ line: ln, expression: expr, variable: varName });
+                    ctx.addFinding({
+                        id: `redundant-loop-computation-${file}-${ln}-math`,
+                        pass: this.name,
+                        category: this.category,
+                        rule_id: this.name,
+                        cwe: 'CWE-1050',
+                        severity: 'low',
+                        level: 'note',
+                        message: `Loop-invariant computation: \`${expr}\` is recomputed on every iteration; hoist outside loop`,
+                        file,
+                        line: ln,
+                        snippet: lineText.trim(),
+                        fix: `Compute \`${expr}\` once before the loop.`,
+                        evidence: { variable: varName, loop_start: start_line, loop_end: end_line },
+                    });
+                }
+            }
+        }
+        return { invariants };
+    }
+}
+//# sourceMappingURL=redundant-loop-pass.js.map