@lzehrung/codegraph-core 2.1.0 → 2.1.2

package/dist/impact/report-suggestions.js

@@ -5,11 +5,15 @@ import { findReferences } from "../indexer/navigation.js";
 import { fileIdentityKey, resolveFilePathFromRoot, toProjectDisplayPath } from "../util/paths.js";
 import { mapLimit } from "../util/concurrency.js";
 import { maskJsLikeCommentsAndStrings } from "../util/comments.js";
+import { findBalancedAngleBrackets, findBalancedBraces, findBalancedParentheses, } from "./call-compatibility/textScanner.js";
 import { listCandidateTestFiles } from "./context.js";
 import { collectHunkLineText, collectRemovedLines } from "./hunks.js";
 import { normalizeImpactFilePath } from "./path.js";
 import { collectImpactSuggestions } from "./suggestions.js";
 import { compileTestPatterns, createIndexTestFileMatcher } from "./testPatterns.js";
+import { ECMASCRIPT_IDENTIFIER_SOURCE } from "../util/identifiers.js";
+const JAVASCRIPT_IDENTIFIER_PATTERN = new RegExp(ECMASCRIPT_IDENTIFIER_SOURCE, "uy");
+const JAVASCRIPT_IDENTIFIER_PART_PATTERN = new RegExp(String.raw `(?:${ECMASCRIPT_IDENTIFIER_SOURCE})|[$_\p{ID_Continue}\u200c\u200d]`, "u");
 const CONFIG_FILE_RE = /(^|\/)(?:tsconfig(?:\.[^./]+)?\.json|jsconfig\.json|vite\.config\.[cm]?[jt]s|webpack\.config\.[cm]?[jt]s|rollup\.config\.[cm]?[jt]s|esbuild\.config\.[cm]?[jt]s|babel\.config\.[cm]?[jt]s|\.eslintrc(?:\.[^./]+)?|prettier\.config\.[cm]?[jt]s|package\.json|pnpm-workspace\.ya?ml|lerna\.json|turbo\.json|nx\.json|\.env(?:\.[^/]*)?)$/i;
 const UNTESTED_CHANGE_REFERENCE_SCAN_LIMIT = 500;
 function matchesConfigSemantics(filePath) {
@@ -208,6 +212,7 @@ function collectConfigAndBreakingSuggestions(index, projectRoot, fileChanges, ch
             for (const change of signatureChanges) {
                 upsertBreakingSuggestion({
                     file: normalized,
+                    ...(change.range ? { range: change.range } : {}),
                     kind: "breakingChange",
                     symbol: change.name,
                     details: change.details,
@@ -374,8 +379,9 @@ async function collectUntestedChangeSuggestions(index, changedSymbols, projectRo
         });
         if (refs.status !== "ok")
             return undefined;
+        const scanMayBeTruncated = refs.references.length >= UNTESTED_CHANGE_REFERENCE_SCAN_LIMIT;
         const hasTestRef = refs.references.some((entry) => testFiles.has(fileIdentityKey(entry.file)));
-        if (hasTestRef)
+        if (hasTestRef && !scanMayBeTruncated)
             return undefined;
         const coverage = coverageByFile.get(symbol.file);
         const coveredLines = countCoveredLinesForRange(coverage, symbol.range);
@@ -389,18 +395,23 @@ async function collectUntestedChangeSuggestions(index, changedSymbols, projectRo
             ? `Coverage currently exercises ${coveredLines}/${totalLines} changed line(s).`
             : "No LCOV or Istanbul coverage data matched this symbol range.";
         const fanIn = fanInByFile.get(fileIdentityKey(symbol.file)) ?? 0;
-        const confidence = confidenceFromSignals({
-            hasCoverageData,
-            coveredLines,
-            totalLines,
-            exported: symbol.exported,
-            fanIn,
-            kind: symbol.kind,
-        });
+        const confidence = scanMayBeTruncated
+            ? "low"
+            : confidenceFromSignals({
+                hasCoverageData,
+                coveredLines,
+                totalLines,
+                exported: symbol.exported,
+                fanIn,
+                kind: symbol.kind,
+            });
         const suggestedCommand = inferTestCommand(candidateNames);
+        const referenceScanNote = scanMayBeTruncated
+            ? `Reference scan reached the ${UNTESTED_CHANGE_REFERENCE_SCAN_LIMIT}-reference cap; test coverage may be under-counted. `
+            : "";
         const details = candidateNames.length
-            ? `Changed symbol has no discovered references in test files. ${coverageSummary} Candidate tests: ${candidateNames.join(", ")}. Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`
-            : `Changed symbol has no discovered references in test files. ${coverageSummary} Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`;
+            ? `${referenceScanNote}Changed symbol has no discovered references in test files. ${coverageSummary} Candidate tests: ${candidateNames.join(", ")}. Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`
+            : `${referenceScanNote}Changed symbol has no discovered references in test files. ${coverageSummary} Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`;
         return {
             file: symbol.file,
             range: symbol.range,
@@ -524,41 +535,113 @@ function countNewlines(text) {
     }
     return count;
 }
-function readBalancedParenContent(text, openParenIndex) {
-    let depth = 0;
-    let quote = null;
-    let escaping = false;
-    for (let index = openParenIndex; index < text.length; index += 1) {
-        const ch = text[index];
-        if (quote) {
-            if (escaping) {
-                escaping = false;
-                continue;
-            }
-            if (ch === "\\") {
-                escaping = true;
-                continue;
-            }
-            if (ch === quote)
-                quote = null;
+function skipWhitespaceAndComments(text, index) {
+    let cursor = index;
+    while (cursor < text.length) {
+        const ch = text[cursor];
+        if (!ch)
+            break;
+        if (/\s/.test(ch)) {
+            cursor += 1;
             continue;
         }
-        if (ch === '"' || ch === "'" || ch === "`") {
-            quote = ch;
+        if (ch === "/" && text[cursor + 1] === "/") {
+            const newline = text.indexOf("\n", cursor + 2);
+            cursor = newline < 0 ? text.length : newline + 1;
             continue;
         }
-        if (ch === "(") {
-            depth += 1;
+        if (ch === "/" && text[cursor + 1] === "*") {
+            const close = text.indexOf("*/", cursor + 2);
+            cursor = close < 0 ? text.length : close + 2;
             continue;
         }
-        if (ch === ")") {
-            depth -= 1;
-            if (!depth) {
-                return { content: text.slice(openParenIndex + 1, index), endIndex: index };
+        break;
+    }
+    return cursor;
+}
+function readIdentifier(text, index) {
+    const ch = text[index];
+    if (!ch)
+        return null;
+    JAVASCRIPT_IDENTIFIER_PATTERN.lastIndex = index;
+    const identifierMatch = JAVASCRIPT_IDENTIFIER_PATTERN.exec(text);
+    if (!identifierMatch)
+        return null;
+    const end = JAVASCRIPT_IDENTIFIER_PATTERN.lastIndex;
+    return { name: text.slice(index, end), end };
+}
+function skipDecorator(text, index) {
+    if (text[index] !== "@")
+        return null;
+    let cursor = skipWhitespaceAndComments(text, index + 1);
+    let segment = readIdentifier(text, cursor);
+    if (!segment)
+        return null;
+    cursor = skipWhitespaceAndComments(text, segment.end);
+    while (text[cursor] === ".") {
+        cursor = skipWhitespaceAndComments(text, cursor + 1);
+        segment = readIdentifier(text, cursor);
+        if (!segment)
+            return null;
+        cursor = skipWhitespaceAndComments(text, segment.end);
+    }
+    if (text[cursor] === "(") {
+        const args = findBalancedParentheses(text, cursor);
+        if (!args)
+            return null;
+        return args.end;
+    }
+    return cursor;
+}
+function skipOptionalGenerics(text, index) {
+    const cursor = skipWhitespaceAndComments(text, index);
+    if (text[cursor] !== "<")
+        return cursor;
+    const close = findBalancedAngleBrackets(text, cursor);
+    return close < 0 ? cursor : close + 1;
+}
+function skipHeritageClause(text, index) {
+    let cursor = skipWhitespaceAndComments(text, index);
+    while (true) {
+        const keyword = readIdentifier(text, cursor);
+        if (!keyword || (keyword.name !== "extends" && keyword.name !== "implements")) {
+            return cursor;
+        }
+        cursor = skipWhitespaceAndComments(text, keyword.end);
+        while (cursor < text.length) {
+            const ch = text[cursor];
+            if (!ch)
+                break;
+            if (ch === "{")
+                return cursor;
+            if (ch === "<") {
+                const close = findBalancedAngleBrackets(text, cursor);
+                if (close < 0)
+                    return cursor;
+                cursor = close + 1;
+                continue;
+            }
+            if (ch === "(") {
+                const balanced = findBalancedParentheses(text, cursor);
+                if (!balanced)
+                    return cursor;
+                cursor = balanced.end;
+                continue;
+            }
+            if (ch === ",") {
+                cursor = skipWhitespaceAndComments(text, cursor + 1);
+                continue;
             }
+            if (/\s/.test(ch)) {
+                cursor = skipWhitespaceAndComments(text, cursor);
+                const next = readIdentifier(text, cursor);
+                if (next && (next.name === "extends" || next.name === "implements"))
+                    break;
+                continue;
+            }
+            cursor += 1;
         }
     }
-    return null;
 }
 function functionSuffixStartsAfterParams(text, closeParenIndex) {
     return /^\s*(?::|[{;])/.test(text.slice(closeParenIndex + 1));
@@ -622,45 +705,231 @@ function arrowSuffixStartsAfterParams(text, closeParenIndex) {
     }
     return false;
 }
-function collectExportSignaturesFromText(text, hunkIndex, startLine) {
-    const output = [];
-    const pushMatch = (match, name, rawParams) => {
-        output.push({
-            name,
-            paramCount: countParams(rawParams),
+function lineRangeAt(text, index, startLine) {
+    const line = startLine + countNewlines(text.slice(0, index));
+    return {
+        start: { line, column: 1 },
+        end: { line, column: 1 },
+    };
+}
+function findConstructorParamCount(classBodyInner) {
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < classBodyInner.length; index += 1) {
+        const ch = classBodyInner[index];
+        if (!ch)
+            continue;
+        if (quote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "{") {
+            depth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            if (depth)
+                depth -= 1;
+            continue;
+        }
+        if (depth !== 0)
+            continue;
+        if (classBodyInner.startsWith("constructor", index) &&
+            !JAVASCRIPT_IDENTIFIER_PART_PATTERN.test(classBodyInner[index - 1] ?? "")) {
+            const cursor = skipWhitespaceAndComments(classBodyInner, index + "constructor".length);
+            if (classBodyInner[cursor] !== "(")
+                continue;
+            const params = findBalancedParentheses(classBodyInner, cursor);
+            if (!params)
+                return null;
+            return countParams(params.inner);
+        }
+    }
+    return 0;
+}
+function tryParseExportedFunction(text, index, hunkIndex, startLine, isDefault) {
+    let cursor = skipWhitespaceAndComments(text, index);
+    const maybeAsync = readIdentifier(text, cursor);
+    if (maybeAsync?.name === "async") {
+        cursor = skipWhitespaceAndComments(text, maybeAsync.end);
+    }
+    const keyword = readIdentifier(text, cursor);
+    if (keyword?.name !== "function")
+        return null;
+    cursor = skipWhitespaceAndComments(text, keyword.end);
+    if (text[cursor] === "*")
+        cursor = skipWhitespaceAndComments(text, cursor + 1);
+    const name = readIdentifier(text, cursor);
+    if (name) {
+        cursor = name.end;
+    }
+    else if (!isDefault) {
+        return null;
+    }
+    const exportName = name?.name ?? "default";
+    cursor = skipOptionalGenerics(text, cursor);
+    cursor = skipWhitespaceAndComments(text, cursor);
+    if (text[cursor] !== "(")
+        return null;
+    const params = findBalancedParentheses(text, cursor);
+    if (!params || !functionSuffixStartsAfterParams(text, params.end - 1))
+        return null;
+    return {
+        signature: {
+            name: exportName,
+            paramCount: countParams(params.inner),
             hunkIndex,
-            line: startLine + countNewlines(text.slice(0, match.index)),
-        });
+            line: lineRangeAt(text, index, startLine).start.line,
+        },
+        end: params.end,
     };
-    const scanText = maskJsLikeCommentsAndStrings(text);
-    const functionRe = /^\s*export\s+(?:default\s+)?(?:async\s+)?function\s*(?:\*\s*)?(?:([A-Za-z_$][\w$]*))?(?:\s*<[^>]+>)?\s*\(/gm;
-    for (let match; (match = functionRe.exec(scanText));) {
-        const params = readBalancedParenContent(scanText, functionRe.lastIndex - 1);
-        if (params && functionSuffixStartsAfterParams(scanText, params.endIndex)) {
-            pushMatch(match, match[1] ?? "default", params.content);
-            functionRe.lastIndex = params.endIndex + 1;
-        }
-    }
-    const arrowRe = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/gm;
-    for (let match; (match = arrowRe.exec(scanText));) {
-        const name = match[1];
-        const params = readBalancedParenContent(scanText, arrowRe.lastIndex - 1);
-        if (name && params && arrowSuffixStartsAfterParams(scanText, params.endIndex)) {
-            pushMatch(match, name, params.content);
-            arrowRe.lastIndex = params.endIndex + 1;
-        }
-    }
-    const singleParamArrowRe = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?([A-Za-z_$][\w$]*)\s*=>/gm;
-    for (let match; (match = singleParamArrowRe.exec(scanText));) {
-        const name = match[1];
-        if (!name)
-            continue;
-        output.push({
-            name,
+}
+function tryParseExportedArrow(text, index, hunkIndex, startLine) {
+    let cursor = skipWhitespaceAndComments(text, index);
+    const binding = readIdentifier(text, cursor);
+    if (binding?.name !== "const" && binding?.name !== "let" && binding?.name !== "var")
+        return null;
+    cursor = skipWhitespaceAndComments(text, binding.end);
+    const name = readIdentifier(text, cursor);
+    if (!name)
+        return null;
+    cursor = skipWhitespaceAndComments(text, name.end);
+    if (text[cursor] !== "=")
+        return null;
+    cursor = skipWhitespaceAndComments(text, cursor + 1);
+    const maybeAsync = readIdentifier(text, cursor);
+    if (maybeAsync?.name === "async") {
+        cursor = skipWhitespaceAndComments(text, maybeAsync.end);
+    }
+    cursor = skipOptionalGenerics(text, cursor);
+    cursor = skipWhitespaceAndComments(text, cursor);
+    if (text[cursor] === "(") {
+        const params = findBalancedParentheses(text, cursor);
+        if (!params || !arrowSuffixStartsAfterParams(text, params.end - 1))
+            return null;
+        return {
+            signature: {
+                name: name.name,
+                paramCount: countParams(params.inner),
+                hunkIndex,
+                line: lineRangeAt(text, index, startLine).start.line,
+            },
+            end: params.end,
+        };
+    }
+    const single = readIdentifier(text, cursor);
+    if (!single)
+        return null;
+    cursor = skipWhitespaceAndComments(text, single.end);
+    if (!(text[cursor] === "=" && text[cursor + 1] === ">"))
+        return null;
+    return {
+        signature: {
+            name: name.name,
             paramCount: 1,
             hunkIndex,
-            line: startLine + countNewlines(text.slice(0, match.index)),
-        });
+            line: lineRangeAt(text, index, startLine).start.line,
+        },
+        end: cursor + 2,
+    };
+}
+function tryParseExportedClass(text, index, hunkIndex, startLine, isDefault) {
+    let cursor = skipWhitespaceAndComments(text, index);
+    const maybeAbstract = readIdentifier(text, cursor);
+    if (maybeAbstract?.name === "abstract") {
+        cursor = skipWhitespaceAndComments(text, maybeAbstract.end);
+    }
+    const keyword = readIdentifier(text, cursor);
+    if (keyword?.name !== "class")
+        return null;
+    cursor = skipWhitespaceAndComments(text, keyword.end);
+    const name = readIdentifier(text, cursor);
+    let exportName = isDefault ? "default" : name?.name;
+    if (name) {
+        exportName = isDefault ? name.name : name.name;
+        cursor = name.end;
+    }
+    else if (!isDefault) {
+        return null;
+    }
+    cursor = skipOptionalGenerics(text, cursor);
+    cursor = skipHeritageClause(text, cursor);
+    cursor = skipWhitespaceAndComments(text, cursor);
+    if (text[cursor] !== "{")
+        return null;
+    const body = findBalancedBraces(text, cursor);
+    if (!body)
+        return null;
+    const paramCount = findConstructorParamCount(body.inner);
+    if (paramCount === null)
+        return null;
+    return {
+        signature: {
+            name: exportName ?? "default",
+            paramCount,
+            hunkIndex,
+            line: lineRangeAt(text, index, startLine).start.line,
+        },
+        end: body.end,
+    };
+}
+function collectExportSignaturesFromText(text, hunkIndex, startLine) {
+    const output = [];
+    const scanText = maskJsLikeCommentsAndStrings(text);
+    let index = 0;
+    while (index < scanText.length) {
+        const exportAt = scanText.indexOf("export", index);
+        if (exportAt < 0)
+            break;
+        const before = exportAt === 0 ? "" : (scanText[exportAt - 1] ?? "");
+        const after = scanText[exportAt + "export".length] ?? "";
+        if ((before && JAVASCRIPT_IDENTIFIER_PART_PATTERN.test(before)) ||
+            (after && JAVASCRIPT_IDENTIFIER_PART_PATTERN.test(after))) {
+            index = exportAt + "export".length;
+            continue;
+        }
+        let cursor = skipWhitespaceAndComments(scanText, exportAt + "export".length);
+        while (true) {
+            const nextDecorator = skipDecorator(scanText, cursor);
+            if (nextDecorator === null)
+                break;
+            cursor = skipWhitespaceAndComments(scanText, nextDecorator);
+        }
+        let isDefault = false;
+        const maybeDefault = readIdentifier(scanText, cursor);
+        if (maybeDefault?.name === "default") {
+            isDefault = true;
+            cursor = skipWhitespaceAndComments(scanText, maybeDefault.end);
+            while (true) {
+                const nextDecorator = skipDecorator(scanText, cursor);
+                if (nextDecorator === null)
+                    break;
+                cursor = skipWhitespaceAndComments(scanText, nextDecorator);
+            }
+        }
+        const parsed = tryParseExportedFunction(scanText, cursor, hunkIndex, startLine, isDefault) ??
+            tryParseExportedClass(scanText, cursor, hunkIndex, startLine, isDefault) ??
+            (!isDefault ? tryParseExportedArrow(scanText, cursor, hunkIndex, startLine) : null);
+        if (parsed) {
+            output.push(parsed.signature);
+            index = parsed.end;
+            continue;
+        }
+        index = exportAt + "export".length;
     }
     return output;
 }
@@ -722,11 +991,16 @@ function detectExportSignatureChanges(change) {
     const output = [];
     for (const removedSig of removed) {
         const matched = bestAddedMatchForRemoved(removedSig);
+        const range = {
+            start: { line: removedSig.line, column: 1 },
+            end: { line: removedSig.line, column: 1 },
+        };
         if (matched && matched.paramCount !== removedSig.paramCount) {
             output.push({
                 name: removedSig.name,
                 details: `Exported function signature changed from ${removedSig.paramCount} parameter(s) to ${matched.paramCount}. This is likely a breaking API change.`,
                 confidence: "high",
+                range,
             });
             continue;
         }
@@ -740,6 +1014,7 @@ function detectExportSignatureChanges(change) {
                 name: removedSig.name,
                 details: renameDetails,
                 confidence: "medium",
+                range,
             });
         }
     }