ucn 5.5.1 → 5.5.3

package/core/analysis.js

@@ -14,7 +14,7 @@ const { UcnError } = require('./errors');
 const { parse } = require('./parser');
 const { detectLanguage, langTraits } = require('../languages');
 const { NON_CALLABLE_TYPES, addTestExclusions, countTextBlindspots,
-    codeUnitCompare, formatSymbolHandle } = require('./shared');
+    codeUnitCompare, formatSymbolHandle, isValueDefinition } = require('./shared');
 const { isTestFile } = require('./discovery');
 // Entry-point detection loads on first use (fix #375).
 let entrypointsModule = null;
@@ -346,6 +346,23 @@ function callNotResolvedEntries(index, account, options = {}) {
  * @param {object} options - { file, className, includeMethods, includeUncertain, exclude, minConfidence }
  * @returns {object|null}
  */
+/**
+ * The hint for a constructor handle with no callers whose declaring class
+ * is unresolved (fix #421): constructions name the class, and without its
+ * definition they cannot be bound to this constructor. Null otherwise: a
+ * constructor of a resolved class receives every construction selecting it.
+ */
+function unownedConstructorHint(index, def, callerCount) {
+    if (callerCount > 0 || !def?.className) return null;
+    const { isConstructor } = require('./constructor-calls');
+    if (!isConstructor(def, index) || require('./class-identity').ownerDefinitionOf(index, def) ||
+        !index.getCalleeFiles(def.className)) return null;
+    return {
+        type: 'hint',
+        message: `The class declaring this constructor was not resolved, so constructions of \`${def.className}\` are not bound to it; query \`${def.className}\` for the construction sites.`,
+    };
+}
+
 function context(index, name, options = {}) {
     index._beginOp();
     try {
@@ -591,6 +608,7 @@ function context(index, name, options = {}) {
         ...(ambiguityCandidates && { ambiguityCandidates }),
         callees,
         unverifiedCallees: rawCallees.unverifiedCallees || [],
+        ...(rawCallees.initializerReviews?.length && { initializerReviews: rawCallees.initializerReviews }),
         callerHistogram,
         calleeHistogram,
         meta: {
@@ -619,18 +637,11 @@ function context(index, name, options = {}) {
         }
     };
 
-    // Constructor pins surface their invocation sites under the CLASS pin
-    // (`new Widget()` indexes under 'Widget' — the fix #239 liveness rule;
-    // fix #254 makes it discoverable): a bare empty answer sent readers
-    // hunting for callers the class pin already has.
-    if (def.className && callers.length === 0 &&
-        (def.type === 'constructor' || name === 'constructor' || name === '__init__') &&
-        index.getCalleeFiles(def.className)) {
-        warnings.push({
-            type: 'hint',
-            message: `Constructor invocations (\`new ${def.className}(...)\` / \`${def.className}(...)\`) are indexed under the class name — query \`${def.className}\` for the call sites.`,
-        });
-    }
+    // A constructor handle lists the constructions that select it (fix
+    // #417). Only a constructor whose declaring class is unresolved cannot
+    // receive them; its class handle still has the sites (fix #421).
+    const unownedHint = unownedConstructorHint(index, def, callers.length);
+    if (unownedHint) warnings.push(unownedHint);
 
     if (warnings.length > 0) {
         result.warnings = warnings;
@@ -711,6 +722,7 @@ function smart(index, name, options = {}) {
         dependencies,
         types,
         unverifiedCallees: smartUnverified,
+        ...(callees.initializerReviews?.length && { initializerReviews: callees.initializerReviews }),
         meta: {
             complete: stats.uncertain === 0 && dynamicImports === 0 && smartUnverified.length === 0,
             skipped: 0,
@@ -991,99 +1003,132 @@ function related(index, name, options = {}) {
  * @param {object} options - { file, className, exclude, top }
  * @returns {object|null}
  */
-// Kinds whose dependents are annotation/reference sites rather than calls.
-// Classes and structs stay out: `new X()` / `X{}` are call-shaped and already
-// flow through the caller sweep.
-const TYPE_REFERENCE_KINDS = new Set(['type', 'interface', 'enum', 'trait', 'record']);
+// Kinds whose dependents include annotation/reference sites (fix #345):
+// every type declaration. A class or struct is also constructed: its
+// constructions are call sites of the caller band, every other token naming
+// it (annotations, bases, casts, qualifiers, imports) a type reference
+// (fix #428).
+const TYPE_REFERENCE_KINDS = new Set(['class', 'struct', 'interface', 'type', 'enum', 'trait', 'record', 'union']);
+// Tokens that declare the type (its own name, its constructors' names).
+const TYPE_DECLARATION_ROLES = new Set(['decl', 'ctor', 'ctor-qualified', 'pin-binding']);
 
 /**
- * fix #345: tiered annotation-site band for a type-kind definition.
- * Confirmed needs identity evidence: same file as the definition, or an
- * import binding of the name in the referencing file that reaches the
- * definition's file (the #215/#217 scope discipline). Anything else is
- * VISIBLE unverified with a reason. A same-name definition elsewhere is
- * excluded as other-target. Spelling alone never confirms.
+ * The type reference band of a type definition (fixes #345, #428): every
+ * token naming the type on the name's ground lines, decided by the
+ * type-rename lookup (core/type-references.js, the language's own name
+ * lookup: lexical shadows, type parameters, imports, packages, namespaces,
+ * include closures). A token the lookup proves names the type is confirmed,
+ * one it cannot settle is unverified with its reason, one naming something
+ * else is excluded with its reason. Tokens at call sites (constructions)
+ * belong to the caller band and declaration tokens to the definitions; the
+ * account partitions all of them.
  */
 function findTypeReferences(index, name, def, options = {}) {
-    if (!def || !TYPE_REFERENCE_KINDS.has(def.type)) return null;
-    const { usages } = require('./search');
-    const { _importReaches, _sameNominalPackageDir } = require('./callers');
-    const records = usages(index, name, {
-        includeTests: true, codeOnly: true, exclude: options.exclude,
-    });
-    const targetFiles = new Set([def.file]);
-    const sameNameDefs = (index.symbols.get(name) || []).filter(d => d !== def);
-    const confirmed = [];
-    const unverified = [];
-    const excluded = [];
-    for (const u of (Array.isArray(records) ? records : records?.usages || [])) {
-        if (u.isDefinition || u.usageType !== 'reference') continue;
-        const site = {
-            file: u.relativePath, line: u.line,
-            expression: (u.content || '').trim(),
-        };
-        // A same-name type defined in the referencing file owns that file's
-        // bare references (the #215 scope rule): excluded, never confirmed.
-        if (u.file !== def.file && sameNameDefs.some(d => d.file === u.file && TYPE_REFERENCE_KINDS.has(d.type))) {
-            excluded.push({ ...site, reason: 'other-definition' });
-            continue;
-        }
-        if (sameNameDefs.some(d => d.file === u.file && (d.nameLine || d.startLine) === u.line)) {
-            excluded.push({ ...site, reason: 'other-definition' });
-            continue;
-        }
-        if (u.file === def.file) {
-            confirmed.push({ ...site, evidence: 'same-file' });
-            continue;
-        }
-        const fileEntry = index.files.get(u.file);
-        // Directory-scoped packages (Go) and Java packages see sibling files'
-        // types without an import; a same-name def in another package would
-        // have been excluded above only if it shared the line, so require the
-        // pinned def to be the package's own.
-        const packageScoped = fileEntry && (
-            (langTraits(fileEntry.language).packageScope === 'directory' &&
-                path.dirname(u.file) === path.dirname(def.file)) ||
-            (fileEntry.language === 'java' &&
-                _sameNominalPackageDir(path.dirname(def.file), path.dirname(u.file), 'java')));
-        if (packageScoped) {
-            const foreign = sameNameDefs.some(d => TYPE_REFERENCE_KINDS.has(d.type) &&
-                path.dirname(d.file) === path.dirname(u.file));
-            if (foreign) unverified.push({ ...site, reason: 'same-package-ambiguous' });
-            else confirmed.push({ ...site, evidence: 'package-scope' });
-            continue;
-        }
-        const bindings = (fileEntry?.importBindings || []).filter(b =>
-            b.name === name || b.alias === name);
-        if (bindings.length > 0) {
-            const reaches = bindings.some(b => {
-                const rel = fileEntry.moduleResolved && fileEntry.moduleResolved[b.module];
-                return rel && _importReaches(index, path.join(index.root, rel), targetFiles);
-            });
-            if (reaches) { confirmed.push({ ...site, evidence: 'import' }); continue; }
-            const otherProject = bindings.some(b =>
-                fileEntry.moduleResolved && fileEntry.moduleResolved[b.module]);
-            if (otherProject) { excluded.push({ ...site, reason: 'other-definition-import' }); continue; }
-            unverified.push({ ...site, reason: 'import-unresolved' });
-            continue;
-        }
-        if (fileEntry?.importNames?.includes('*')) {
-            unverified.push({ ...site, reason: 'star-import' });
-            continue;
+    if (!def || !TYPE_REFERENCE_KINDS.has(def.type) || def.isMethod) return null;
+    const { TypeReferenceResolver, typeReferenceSites, csharpAttributeShortSites } = require('./type-references');
+    const { computeGroundSet } = require('./account');
+    const { getCachedCalls, _recordIsNoCall } = require('./callers');
+    const resolver = new TypeReferenceResolver(index, def, name);
+    resolver.collectRoles = true;
+    const ground = computeGroundSet(index, name);
+    const scopedGround = options.files ? { ...ground,
+        perFile: new Map([...ground.perFile].filter(([file]) => options.files.has(file))) } : ground;
+    const { files } = typeReferenceSites(index, def, name, scopedGround, resolver);
+    const confirmed = [], unverified = [], excluded = [];
+    let tokens = 0, lineCount = 0, textLines = 0, constructions = 0, declarations = 0;
+    const scannedFiles = new Set();
+    const roleKind = role => role === 'value' || role === 'shorthand' ? 'value' : role === 'import' ? 'import'
+        : role === 'string-annotation' ? 'annotation-string' : role === 'doc-cref' ? 'doc-reference'
+            : role === 'member' ? 'member' : 'type';
+    for (const [absoluteFile, info] of [...files].sort((a, b) => codeUnitCompare(a[1].relativePath, b[1].relativePath))) {
+        const file = info.relativePath;
+        if (!index.matchesFilters(file, options) || options.files && !options.files.has(absoluteFile)) continue;
+        // One split of the file and one grouping of its call records by line.
+        let fileLines;
+        try { fileLines = index._getFileLines(absoluteFile) || []; } catch { fileLines = []; }
+        let callsByLine = null;
+        for (const [line, slot] of [...info.lines].sort((a, b) => a[0] - b[0])) {
+            const expression = String(fileLines[line - 1] || '').trim();
+            if (slot.tokens === 0 && slot.reviews.length === 0) {
+                if (slot.text && !slot.macroBody) { textLines++; continue; }
+                // The name outside every parsed token and comment: code the
+                // lookup cannot read (a macro body, an unparsed region).
+                lineCount++;
+                scannedFiles.add(absoluteFile);
+                unverified.push({ file, line, expression, kind: 'unparsed',
+                    reason: slot.unparsedReason || (slot.macroBody ? 'macro-body' : 'unparsed-occurrence'), tier: 'unverified' });
+                continue;
+            }
+            if (slot.tokens > 0) { lineCount++; scannedFiles.add(absoluteFile); }
+            tokens += slot.tokens;
+            // Call-site tokens of the line: the construction records' name
+            // columns; records without a column, by the token's AST position.
+            if (!callsByLine) {
+                callsByLine = new Map();
+                for (const call of getCachedCalls(index, absoluteFile) || []) {
+                    if (call.name !== name && !(call.receiverIsTypeQualified && call.receiver === name)) continue;
+                    if (!callsByLine.has(call.line)) callsByLine.set(call.line, []);
+                    callsByLine.get(call.line).push(call);
+                }
+            }
+            // A cast or a member initializer spelled like a call is no call.
+            // A static member call through the type (`Key.get(..)`, Java and
+            // C#) is a type-qualifier site of the caller band too.
+            const lineCalls = (callsByLine.get(line) || []).filter(call => !_recordIsNoCall(index, absoluteFile, call));
+            // A default or list initialization (`Foo y;`, `Foo z{}`, fix
+            // #421) is recorded at its declarator and a qualified call at its
+            // member: the type token is the nearest name token before it.
+            const lineTokens = [...slot.edits, ...slot.reviews.map(review => review.column),
+                ...(slot.skipColumns || [])].filter(Number.isInteger).sort((a, b) => a - b);
+            const callColumns = new Set(lineCalls.map(call => {
+                const column = call.column ?? call.callSite?.column;
+                const before = call.name !== name || ['default', 'list'].includes(call.constructorSyntax);
+                if (!Number.isInteger(column) || !before || lineTokens.includes(column)) return column;
+                return lineTokens.filter(token => token < column).pop();
+            }).filter(Number.isInteger));
+            const columnless = lineCalls.some(call => !Number.isInteger(call.column ?? call.callSite?.column));
+            const atCall = column => callColumns.has(column) ||
+                (columnless && (slot.constructionColumns || []).includes(column));
+            const roleAt = column => slot.roles?.get(column);
+            const site = (column, extra) => ({ file, line, ...(Number.isInteger(column) && { column }), expression, ...extra });
+            for (const column of slot.edits) {
+                const role = roleAt(column);
+                if (TYPE_DECLARATION_ROLES.has(role)) { declarations++; continue; }
+                if (atCall(column)) { constructions++; continue; }
+                confirmed.push(site(column, { kind: roleKind(role), tier: 'confirmed' }));
+            }
+            for (const review of slot.reviews) {
+                if (Number.isInteger(review.column) && atCall(review.column)) { constructions++; continue; }
+                unverified.push(site(review.column, { kind: roleKind(roleAt(review.column)),
+                    reason: review.reason || 'unresolved', tier: 'unverified' }));
+            }
+            for (const column of slot.skipColumns || []) {
+                if (atCall(column)) { constructions++; continue; }
+                excluded.push(site(column, { reason: slot.skipReasons?.get(column) || 'other-declaration' }));
+            }
         }
-        unverified.push({ ...site, reason: 'no-import-link' });
     }
-    if (confirmed.length === 0 && unverified.length === 0 && excluded.length === 0) {
-        return { owner: def.type, confirmedCount: 0, unverifiedCount: 0, totalCandidates: 0,
-            byFile: [], unverifiedSites: [], excluded: { total: 0, byReason: {} } };
+    // C# applies `XAttribute` as `[X]` (fix #390): the short spellings.
+    let attributeTokens = 0;
+    for (const short of csharpAttributeShortSites(index, def, name)) {
+        if (!index.matchesFilters(short.relativePath, options) || options.files && !options.files.has(short.file)) continue;
+        attributeTokens++;
+        const entry = { file: short.relativePath, line: short.line, column: short.column,
+            expression: (index.getLineContent(short.file, short.line) || '').trim(), kind: 'attribute' };
+        if (short.verdict === 'yes') confirmed.push({ ...entry, tier: 'confirmed' });
+        else if (short.verdict === 'unknown') unverified.push({ ...entry, reason: short.reason || 'unresolved', tier: 'unverified' });
+        else excluded.push({ ...entry, reason: short.reason || 'other-declaration' });
     }
-    const bySite = (a, b) => a.file !== b.file ? codeUnitCompare(a.file, b.file) : a.line - b.line;
+    const bySite = (a, b) => codeUnitCompare(a.file, b.file) || a.line - b.line || (a.column ?? -1) - (b.column ?? -1);
     confirmed.sort(bySite); unverified.sort(bySite);
     const byFile = new Map();
-    for (const site of confirmed) {
-        if (!byFile.has(site.file)) byFile.set(site.file, []);
-        byFile.get(site.file).push(site);
+    for (const entry of confirmed) {
+        if (!byFile.has(entry.file)) byFile.set(entry.file, []);
+        byFile.get(entry.file).push(entry);
     }
+    const tokenSites = unverified.filter(entry => entry.kind !== 'unparsed').length;
+    const allTokens = tokens + attributeTokens;
+    const decided = confirmed.length + tokenSites + excluded.length + constructions + declarations;
     return {
         owner: def.type,
         confirmedCount: confirmed.length,
@@ -1093,7 +1138,14 @@ function findTypeReferences(index, name, def, options = {}) {
         unverifiedSites: unverified,
         excluded: {
             total: excluded.length,
-            byReason: excluded.reduce((out, s) => { out[s.reason] = (out[s.reason] || 0) + 1; return out; }, {}),
+            byReason: excluded.reduce((out, entry) => { out[entry.reason] = (out[entry.reason] || 0) + 1; return out; }, {}),
+        },
+        account: {
+            tokens: allTokens, lines: lineCount, files: scannedFiles.size, textLines,
+            confirmed: confirmed.length, unverified: tokenSites, unparsedLines: unverified.length - tokenSites,
+            excluded: excluded.length, constructions, declarations,
+            ...(attributeTokens > 0 && { attributeTokens }),
+            conserved: decided === allTokens,
         },
     };
 }
@@ -1416,6 +1468,29 @@ function impact(index, name, options = {}) {
     // dependents. Same design as the accessor band: a separate band, never
     // fake caller edges (the caller oracle and the account stay call-shaped).
     let typeReferences = findTypeReferences(index, name, def, options);
+    const valueAccesses = isValueDefinition(def)
+        ? require('./value-references').findValueReferences(index, name, def, {
+            includeTests: true, exclude: options.exclude,
+        }) : null;
+
+    // A value token that is also a call is one dependency site (fix #420):
+    // the value band lists every token, the call band only the calls.
+    const valueOnlyCount = valueAccesses ? (() => {
+        const calls = new Map();
+        for (const site of filteredSites) {
+            const key = `${site.file}\0${site.line}`;
+            calls.set(key, (calls.get(key) || 0) + 1);
+        }
+        let count = 0;
+        for (const group of valueAccesses.byFile) {
+            for (const site of group.sites) {
+                const key = `${site.file}\0${site.line}`;
+                if (calls.get(key) > 0) calls.set(key, calls.get(key) - 1);
+                else count++;
+            }
+        }
+        return count;
+    })() : 0;
 
     // Apply top limit if specified (limits total call sites shown)
     const totalBeforeLimit = filteredSites.length;
@@ -1464,6 +1539,8 @@ function impact(index, name, options = {}) {
         ...(propertyAccesses?.unverifiedSites || []).map(site => site.file),
         ...(typeReferences?.byFile || []).map(group => group.file),
         ...(typeReferences?.unverifiedSites || []).map(site => site.file),
+        ...(valueAccesses?.byFile || []).map(group => group.file),
+        ...(valueAccesses?.unverifiedSites || []).map(site => site.file),
     ]);
 
     return {
@@ -1486,6 +1563,11 @@ function impact(index, name, options = {}) {
             totalDependencySites: totalBeforeLimit + typeReferences.confirmedCount,
             affectedFiles: affectedFiles.size,
         }),
+        ...(valueAccesses && {
+            valueAccesses,
+            totalDependencySites: totalBeforeLimit + valueOnlyCount,
+            affectedFiles: affectedFiles.size,
+        }),
         account: impactAccount,
         hasEntrypoints: !!impactReachable && impactReachable.size > 0,
         callerHistogram,
@@ -1572,7 +1654,7 @@ function about(index, name, options = {}) {
             // ("Using <def>...") stays consistent with the count.
             const visible = definitions.filter(d => {
                 if (d === primary || (d.relativePath === primary.relativePath && d.startLine === primary.startLine)) return true;
-                const lang = detectLanguage(d.file);
+                const lang = index.languageOf(d.file);
                 if (isTestFile(d.relativePath, lang) || isTestPath(d.relativePath)) return false;
                 return true;
             });
@@ -1831,6 +1913,7 @@ function about(index, name, options = {}) {
             ...(c.paramsStructured && { paramsStructured: c.paramsStructured }),
             ...(c.docstring && { docstring: c.docstring }),
             ...(c.sideEffects && c.sideEffects.length && { sideEffects: c.sideEffects }),
+            ...(c.initializerOf && { initializerOf: c.initializerOf }),
         }));
     }
 
@@ -1964,16 +2047,8 @@ function about(index, name, options = {}) {
         completeness: detectCompleteness(index)
     };
 
-    // Constructor pins surface their invocation sites under the CLASS pin
-    // (`new Widget()` indexes under 'Widget' — fix #254, same hint as context).
-    if (primary.className && (callers?.length ?? 0) === 0 &&
-        (primary.type === 'constructor' || symbolName === 'constructor' || symbolName === '__init__') &&
-        index.getCalleeFiles(primary.className)) {
-        result.warnings = [...(result.warnings || []), {
-            type: 'hint',
-            message: `Constructor invocations (\`new ${primary.className}(...)\` / \`${primary.className}(...)\`) are indexed under the class name — query \`${primary.className}\` for the call sites.`,
-        }];
-    }
+    const unownedHint = unownedConstructorHint(index, primary, callers?.length ?? 0);
+    if (unownedHint) result.warnings = [...(result.warnings || []), unownedHint];
 
     return result;
     } finally { index._endOp(); }
@@ -2129,7 +2204,7 @@ function diffImpact(index, options = {}) {
     let nonSourcePaths = 0;
 
     for (const change of changes) {
-        const lang = detectLanguage(change.filePath);
+        const lang = index.languageOf(change.filePath);
         if (!lang || (change.untracked && !index.files.has(change.filePath))) {
             nonSourcePaths++;
             continue;
@@ -2174,6 +2249,7 @@ function diffImpact(index, options = {}) {
         let oldCallables = null;        // old symbols WITH ranges — deleted lines are old-file coordinates
         let oldParsed = null;
         let oldLines = null;
+        let oldText = null;
         if (change.deletedLines.length > 0 || change.addedLines.length > 0) {
             const ref = staged ? 'HEAD' : base;
             try {
@@ -2181,9 +2257,10 @@ function diffImpact(index, options = {}) {
                     'git', ['show', `${ref}:${change.gitRelativePath}`],
                     { cwd: index.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }
                 );
-                const fileLang = detectLanguage(change.filePath);
+                const fileLang = index.languageOf(change.filePath);
                 if (fileLang) {
                     oldParsed = parse(oldContent, fileLang);
+                    oldText = oldContent;
                     oldLines = oldContent.split('\n');
                     oldSymbolIdentities = new Set();
                     oldCallables = extractCallableSymbols(oldParsed);
@@ -2198,17 +2275,61 @@ function diffImpact(index, options = {}) {
 
         collectNonCallableChanges(index, change, oldParsed, fileEntry.symbols, symbolChanges, oldLines);
 
+        // Several callables can share a changed line (`class Box {
+        // constructor(v) {..} get w() {..} }`, fix #434): the line belongs
+        // to each whose own source changed, a callable whose text equals its
+        // base twin's is unchanged by it.
+        let currentText = null;
+        const spanText = (text, s) => text != null && s?.sourceSpan &&
+            Number.isInteger(s.sourceSpan.start) && Number.isInteger(s.sourceSpan.end)
+            ? text.slice(s.sourceSpan.start, s.sourceSpan.end) : null;
+        const unchangedMemo = new Map();
+        const unchangedCallable = symbol => {
+            if (unchangedMemo.has(symbol)) return unchangedMemo.get(symbol);
+            let unchanged = false;
+            if (oldCallables !== null && symbol.sourceSpan) {
+                if (currentText === null) {
+                    try { currentText = index._readFile(change.filePath); } catch { currentText = undefined; }
+                }
+                const text = spanText(currentText, symbol);
+                unchanged = text != null && oldCallables.some(old => old.name === symbol.name &&
+                    (old.className || '') === (symbol.className || '') && spanText(oldText, old) === text);
+            }
+            unchangedMemo.set(symbol, unchanged);
+            return unchanged;
+        };
         for (const line of change.addedLines) {
             // Arrow fields are indexed as fields but their bodies still need
             // callable impact once declaration-only changes are separated out.
-            const symbol = index.findEnclosingFunction(change.filePath, line, true) ||
+            const primary = index.findEnclosingFunction(change.filePath, line, true) ||
                 fileEntry.symbols.find(s => isDiffCallable(s) && s.startLine <= line && s.endLine >= line);
-            if (symbol) {
-                const key = `${symbol.name}:${symbol.startLine}`;
-                if (!affectedSymbols.has(key)) {
-                    affectedSymbols.set(key, { symbol, addedLines: [], deletedLines: [] });
+            let lineSymbols = primary ? [primary] : [];
+            if (primary) {
+                const disjoint = (a, b) => a.sourceSpan && b.sourceSpan &&
+                    (a.sourceSpan.end <= b.sourceSpan.start || b.sourceSpan.end <= a.sourceSpan.start);
+                const siblings = fileEntry.symbols.filter(s => s !== primary && isDiffCallable(s) &&
+                    s.startLine <= line && s.endLine >= line && disjoint(s, primary) &&
+                    !fileEntry.symbols.some(inner => inner !== s && isDiffCallable(inner) && inner.sourceSpan && s.sourceSpan &&
+                        inner.sourceSpan.start >= s.sourceSpan.start && inner.sourceSpan.end <= s.sourceSpan.end &&
+                        inner.startLine <= line && inner.endLine >= line));
+                // Only a line inside the callable's own source span: an
+                // attribute or decorator line outside it changes the callable.
+                const spans = s => s.sourceSpan?.startLine != null && s.sourceSpan.startLine <= line &&
+                    line <= s.sourceSpan.endLine;
+                lineSymbols = [primary, ...siblings].filter(s => !(spans(s) && unchangedCallable(s)));
+            }
+            if (lineSymbols.length > 0) {
+                for (const symbol of lineSymbols) {
+                    const key = `${symbol.name}:${symbol.startLine}`;
+                    if (!affectedSymbols.has(key)) {
+                        affectedSymbols.set(key, { symbol, addedLines: [], deletedLines: [] });
+                    }
+                    affectedSymbols.get(key).addedLines.push(line);
                 }
-                affectedSymbols.get(key).addedLines.push(line);
+            } else if (primary) {
+                // Every callable on the line is unchanged: the line's other
+                // tokens changed.
+                continue;
             } else {
                 // Module-level change
                 const existing = moduleLevelChanges.find(m => m.filePath === change.filePath);
@@ -2266,11 +2387,16 @@ function diffImpact(index, options = {}) {
                         for (const c of candidates) {
                             if (Math.abs(c.startLine - bestOld.startLine) < Math.abs(cur.startLine - bestOld.startLine)) cur = c;
                         }
-                        const key = `${cur.name}:${cur.startLine}`;
-                        if (!affectedSymbols.has(key)) {
-                            affectedSymbols.set(key, { symbol: cur, addedLines: [], deletedLines: [] });
+                        // A callable whose own text is unchanged is not
+                        // what the deleted line changed (fix #434).
+                        if (!(bestOld.sourceSpan?.startLine != null && bestOld.sourceSpan.startLine <= line &&
+                            line <= bestOld.sourceSpan.endLine && unchangedCallable(cur))) {
+                            const key = `${cur.name}:${cur.startLine}`;
+                            if (!affectedSymbols.has(key)) {
+                                affectedSymbols.set(key, { symbol: cur, addedLines: [], deletedLines: [] });
+                            }
+                            affectedSymbols.get(key).deletedLines.push(line);
                         }
-                        affectedSymbols.get(key).deletedLines.push(line);
                     }
                     // Identity gone → the whole function was deleted; the
                     // deletion detection below reports it. Its body lines are
@@ -2553,8 +2679,10 @@ function diffImpact(index, options = {}) {
         totalCallSites += evidence.totalCallSites || 0;
         totalUnverifiedSites += evidence.unverifiedSites?.length || 0;
         for (const group of evidence.byFile || []) callerFileSet.add(path.resolve(index.root, group.file));
-        const refs = evidence.typeReferences || evidence.propertyAccesses;
-        totalDependencySites += refs?.confirmedCount || 0;
+        const refs = evidence.typeReferences || evidence.propertyAccesses || evidence.valueAccesses;
+        // Non-call sites only: a value band also lists the call tokens.
+        totalDependencySites += refs && Number.isInteger(evidence.totalDependencySites)
+            ? Math.max(0, evidence.totalDependencySites - (evidence.totalCallSites || 0)) : refs?.confirmedCount || 0;
         unverifiedDependencySites += refs?.unverifiedCount || 0;
         for (const group of refs?.byFile || []) dependencyFiles.add(group.file);
         for (const site of refs?.unverifiedSites || []) dependencyFiles.add(site.file);
@@ -2609,7 +2737,7 @@ function collectNonCallableChanges(index, change, oldParsed, currentSymbols, out
         before.get(key).push(s);
     }
     const touches = (s, lines) => lines.some(line => line >= s.startLine && line <= (s.endLine || s.startLine));
-    const language = detectLanguage(change.filePath);
+    const language = index.languageOf(change.filePath);
     let currentSnapshots = new Map();
     let oldSnapshots = new Map();
     // Unsupported/recovered declaration shapes retain conservative range
@@ -2697,13 +2825,15 @@ function extractCallableSymbols(parsed) {
     const signature = s => ({ params: s.params, paramsStructured: s.paramsStructured, generics: s.generics });
     for (const fn of parsed.functions) {
         const className = fn.className || (fn.receiver ? fn.receiver.replace(/^\*/, '') : '');
-        symbols.push({ name: fn.name, className, startLine: fn.startLine, endLine: fn.endLine, ...signature(fn) });
+        symbols.push({ name: fn.name, className, startLine: fn.startLine, endLine: fn.endLine, ...signature(fn),
+            ...(fn.sourceSpan && { sourceSpan: fn.sourceSpan }) });
     }
     for (const cls of parsed.classes) {
         if (cls.members) {
             for (const m of cls.members) {
                 if (!isDiffCallable(m)) continue;
-                symbols.push({ name: m.name, className: cls.name, startLine: m.startLine, endLine: m.endLine, ...signature(m) });
+                symbols.push({ name: m.name, className: cls.name, startLine: m.startLine, endLine: m.endLine, ...signature(m),
+                    ...(m.sourceSpan && { sourceSpan: m.sourceSpan }) });
             }
         }
     }
@@ -3568,4 +3698,6 @@ module.exports = {
     // Shared with tracing.js (trace/blast/reverseTrace root accounts) — the
     // tree commands compose the same text-ground account at their root hop.
     composeAccount,
+    // Test discovery shares impact's per-token type-reference evidence.
+    findTypeReferences,
 };

package/core/ast-analysis.js

@@ -37,7 +37,10 @@ const DECLARATION_NODES = {
     trait: new Set(['trait_item']),
     impl: new Set(['impl_item']),
     record: new Set(['record_declaration']),
-    field: new Set(['field_definition', 'public_field_definition', 'property_signature', 'field_declaration', 'variable_declarator']),
+    // An instance attribute a method assigns on its receiver (`this.v = v`,
+    // `self.v = v`) is declared by that assignment (fix #434).
+    field: new Set(['field_definition', 'public_field_definition', 'property_signature', 'field_declaration', 'variable_declarator',
+        'assignment_expression', 'assignment']),
     state: new Set(['variable_declarator', 'assignment', 'init_declarator', 'const_item', 'static_item', 'const_spec', 'var_spec']),
 };
 const FUNCTION_EXPRESSIONS = new Set([
@@ -72,7 +75,9 @@ function declarationSnapshots(content, language, symbols) {
         if (!node) return false;
         if (node.text === name) return true;
         return hasName(node.childForFieldName('name') || node.childForFieldName('declarator') ||
-            (node.type === 'generic_type' && node.childForFieldName('type')), name);
+            (node.type === 'generic_type' && node.childForFieldName('type')) ||
+            (['member_expression', 'attribute'].includes(node.type) &&
+                (node.childForFieldName('property') || node.childForFieldName('attribute'))), name);
     };
     for (const symbol of symbols) {
         const kinds = DECLARATION_NODES[symbol.type];
@@ -400,7 +405,11 @@ function projectComputedDispatch(index) {
     const byFile = new Map();
     for (const [filePath, fileEntry] of index.files) {
         try {
-            const sites = computedDispatchSites(index._readFile(filePath), fileEntry.language);
+            // Extracted at index time from the file's literal parse (fix
+            // #436); an entry without them is read here.
+            const sites = Array.isArray(fileEntry.computedDispatchSites)
+                ? fileEntry.computedDispatchSites.map(site => ({ ...site }))
+                : computedDispatchSites(index._readFile(filePath), fileEntry.language);
             if (sites.length > 0) byFile.set(filePath, sites);
         } catch (_) {
             // Unreadable files are reported through the existing parse/read