recon-generate 0.0.9 → 0.0.10

package/dist/processor.js

@@ -107,21 +107,28 @@ const matchesSignature = (sig, allowed) => {
         return true;
     return false;
 };
-const processFunction = (fnDef, includeDeps = false) => {
+const processFunction = (fnDef, includeDeps = false, visited = new Set()) => {
     const result = [];
+    if (visited.has(fnDef.id)) {
+        return result;
+    }
+    visited.add(fnDef.id);
     fnDef.walk((n) => {
         if ('vReferencedDeclaration' in n &&
             n.vReferencedDeclaration &&
             n.vReferencedDeclaration !== fnDef) {
             if (n.vReferencedDeclaration instanceof $.FunctionDefinition ||
                 n.vReferencedDeclaration instanceof $.ModifierDefinition) {
-                const refSourceUnit = n.vReferencedDeclaration.getClosestParentByType($.SourceUnit);
+                if (visited.has(n.vReferencedDeclaration.id)) {
+                    return; // break potential recursion cycles
+                }
                 if (result.some((x) => x.ast === n.vReferencedDeclaration)) {
                     return;
                 }
+                const nextVisited = new Set(visited);
                 result.push({
                     ast: n.vReferencedDeclaration,
-                    children: processFunction(n.vReferencedDeclaration, includeDeps),
+                    children: processFunction(n.vReferencedDeclaration, includeDeps, nextVisited),
                     callType: n instanceof $.FunctionCall ? (0, utils_1.getCallType)(n) : types_1.CallType.Internal,
                 });
             }
@@ -165,14 +172,130 @@ const skipPatterns = [
     'lib/chimera/',
     'lib/setup-helpers/',
 ];
+/**
+ * Normalizes a path by stripping common prefixes like /recon/ that some servers add.
+ * This ensures consistent path handling across different environments.
+ */
+const normalizePath = (relPath) => {
+    // Strip leading /recon/ or recon/ prefix if present
+    let normalized = relPath.replace(/^\/?(recon)\//i, '');
+    // Ensure no leading slash for relative paths
+    normalized = normalized.replace(/^\/+/, '');
+    return normalized;
+};
+/**
+ * Checks if a line should be excluded from coverage.
+ * Lines that Echidna cannot report on:
+ * - Empty lines or whitespace-only lines
+ * - Comment-only lines (// ...) but NOT lines with code before comment
+ * - Lines with only "}"
+ * - Lines with only "});"
+ * - Lines with only "} else {"
+ */
+const isUncoverableLine = (line) => {
+    const trimmed = line.trim();
+    // Empty or whitespace-only
+    if (trimmed === '')
+        return true;
+    // Comment-only line (starts with //)
+    if (/^\/\//.test(trimmed))
+        return true;
+    // Block comment only line
+    if (/^\/\*.*\*\/$/.test(trimmed))
+        return true;
+    if (/^\*/.test(trimmed))
+        return true; // middle of block comment
+    if (/^\/\*/.test(trimmed) && !/\*\//.test(trimmed))
+        return true; // start of multi-line block comment
+    // Lines with only closing braces/brackets
+    if (trimmed === '}')
+        return true;
+    if (trimmed === '});')
+        return true;
+    if (trimmed === ')')
+        return true;
+    if (trimmed === ');')
+        return true;
+    if (trimmed === '_;')
+        return true;
+    if (trimmed === '} else {')
+        return true;
+    if (trimmed === '} else if')
+        return true;
+    if (/^\}\s*else\s*\{$/.test(trimmed))
+        return true;
+    if (/^\}\s*else\s+if\s*\(/.test(trimmed))
+        return true;
+    // Unchecked blocks
+    if (trimmed === 'unchecked {')
+        return true;
+    if (/^unchecked\s*\{$/.test(trimmed))
+        return true;
+    return false;
+};
+/**
+ * Filters a range of lines, removing uncoverable lines and splitting into valid sub-ranges.
+ * @param lines Array of all lines in the file (0-indexed)
+ * @param startLine 1-based start line
+ * @param endLine 1-based end line
+ * @returns Array of range strings (e.g., ["5", "7-9", "12"])
+ */
+const filterLineRange = (lines, startLine, endLine) => {
+    var _a;
+    const result = [];
+    let rangeStart = null;
+    for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
+        const lineIndex = lineNum - 1; // Convert to 0-based index
+        const line = (_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '';
+        if (isUncoverableLine(line)) {
+            // End current range if we have one
+            if (rangeStart !== null) {
+                const rangeEnd = lineNum - 1;
+                result.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+                rangeStart = null;
+            }
+        }
+        else {
+            // Start new range or continue existing one
+            if (rangeStart === null) {
+                rangeStart = lineNum;
+            }
+        }
+    }
+    // Close any remaining range
+    if (rangeStart !== null) {
+        result.push(rangeStart === endLine ? `${rangeStart}` : `${rangeStart}-${endLine}`);
+    }
+    return result;
+};
 async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
+    var _a;
     const coverage = new Map();
     const fileCache = new Map();
+    const fileLinesCache = new Map();
     let nodesVisited = 0;
     let nodesAdded = 0;
     const shouldSkipPath = (relPath) => {
         return skipPatterns.some((p) => relPath.includes(p));
     };
+    const getFileLines = async (absPath) => {
+        let lines = fileLinesCache.get(absPath);
+        if (!lines) {
+            let content = fileCache.get(absPath);
+            if (!content) {
+                try {
+                    content = await fs.readFile(absPath, 'utf8');
+                    fileCache.set(absPath, content);
+                }
+                catch {
+                    return [];
+                }
+            }
+            lines = content.split('\n');
+            fileLinesCache.set(absPath, lines);
+        }
+        return lines;
+    };
     const addNodeRange = async (node) => {
         var _a;
         nodesVisited++;
@@ -239,14 +362,57 @@ async function buildCoverageMap(asts, foundryRoot, contractFunctions) {
     }
     const normalized = {};
     for (const [relPath, ranges] of coverage.entries()) {
-        if (shouldSkipPath(relPath)) {
+        // Normalize the path to handle /recon/ prefix
+        const normalizedRelPath = normalizePath(relPath);
+        if (shouldSkipPath(normalizedRelPath)) {
             continue; // skip test/script/lib files at the final emission step only
         }
-        const sorted = Array.from(ranges).sort((a, b) => {
-            const start = (val) => parseInt(val.split('-')[0], 10);
-            return start(a) - start(b);
-        });
-        normalized[relPath] = sorted;
+        const absPath = path.isAbsolute(relPath)
+            ? relPath
+            : path.join(foundryRoot, relPath);
+        const lines = await getFileLines(absPath);
+        // Expand all ranges, filter uncoverable lines, and collect valid line numbers
+        const validLines = new Set();
+        for (const range of ranges) {
+            const parts = range.split('-');
+            const start = parseInt(parts[0], 10);
+            const end = parts.length > 1 ? parseInt(parts[1], 10) : start;
+            for (let lineNum = start; lineNum <= end; lineNum++) {
+                const lineIndex = lineNum - 1;
+                const line = (_a = lines[lineIndex]) !== null && _a !== void 0 ? _a : '';
+                if (!isUncoverableLine(line)) {
+                    validLines.add(lineNum);
+                }
+            }
+        }
+        // Convert valid line numbers back to ranges
+        const sortedLines = Array.from(validLines).sort((a, b) => a - b);
+        const filteredRanges = [];
+        let rangeStart = null;
+        let rangeEnd = null;
+        for (const lineNum of sortedLines) {
+            if (rangeStart === null) {
+                rangeStart = lineNum;
+                rangeEnd = lineNum;
+            }
+            else if (lineNum === rangeEnd + 1) {
+                rangeEnd = lineNum;
+            }
+            else {
+                // Emit previous range
+                filteredRanges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+                rangeStart = lineNum;
+                rangeEnd = lineNum;
+            }
+        }
+        // Emit final range
+        if (rangeStart !== null) {
+            filteredRanges.push(rangeStart === rangeEnd ? `${rangeStart}` : `${rangeStart}-${rangeEnd}`);
+        }
+        if (filteredRanges.length > 0) {
+            // Use normalized path as key for consistent output
+            normalized[normalizedRelPath] = filteredRanges;
+        }
     }
     return normalized;
 }

package/package.json

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