ucn 5.5.1 → 5.5.2

package/core/macro-expansion.js

@@ -384,6 +384,37 @@ function macroBodyTokens(index, def) {
     return expansionState(index).tokensOf(def);
 }
 
+class DeclarationChoice extends Error {
+    constructor(name, definitions) { super(name); this.definitions = definitions; }
+}
+
+/** Expand every bounded macro configuration of a declaration fragment. */
+function expandDeclaration(index, file, line, source) {
+    const state = expansionState(index);
+    const pending = [new Map()], variants = [];
+    while (pending.length) {
+        const choices = pending.pop();
+        const site = { file, line, lines: index._getFileLines(file), fileState: {},
+            lookupMemo: new Map(), usedDefs: new Set(), budget: MAX_TOKENS, ambiguous: false,
+            declarationChoices: choices };
+        try {
+            const tokens = expandTokens(index, state, site, lexPP(source), new Set(), 0);
+            const text = tokens.map(token => token.v).join(' ');
+            const complete = !site.ambiguous && !tokens.some(token => token.opaque || token.noexpand);
+            if (!variants.some(variant => variant.text === text)) variants.push({ text, complete });
+        } catch (error) {
+            if (error instanceof DeclarationChoice) {
+                if (pending.length + variants.length + error.definitions.length > MAX_VARIANTS) {
+                    variants.push({ text: source, complete: false }); break;
+                }
+                for (const definition of error.definitions) pending.push(new Map(choices).set(error.message, definition));
+            } else if (error instanceof BlindExpansion) variants.push({ text: source, complete: false });
+            else throw error;
+        }
+    }
+    return { ...variants[0], complete: variants.length === 1 && variants[0].complete, variants };
+}
+
 /** Does an invocation with `args` fit the macro's parameter list? */
 function arityFits(def, args) {
     const params = def.ppParams || [];
@@ -508,7 +539,12 @@ function expandTokens(index, state, site, tokens, hide, depth) {
             out.push({ ...t, noexpand: true });
             continue;
         }
-        const scope = definitionsInScope(index, state, site, t.v);
+        let scope = definitionsInScope(index, state, site, t.v);
+        if (site.declarationChoices && scope.defs.length > 1 && !scope.truncated) {
+            const chosen = site.declarationChoices.get(t.v);
+            if (!chosen) throw new DeclarationChoice(t.v, scope.defs);
+            scope = { defs: [chosen], ambiguous: false, truncated: false };
+        }
         let def = scope.defs[0];
         if (!def) {
             out.push(t);
@@ -1413,4 +1449,4 @@ function macroExpansionSummary(index) {
 }
 
 module.exports = { withMacroExpansion, macroExpansionSummary, expansionState, persistableMacroExpansion,
-    macroDefinitionsAt, macroBodyTokens, codeTokens, pastedNameSites };
+    macroDefinitionsAt, macroBodyTokens, expandDeclaration, codeTokens, pastedNameSites };

package/core/out-of-class-members.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * core/out-of-class-members.js - constructors defined outside their class
+ * body (fix #421): the C++ header + source layout, where `W::W(int)` in
+ * w.cpp defines the `W(int)` its class declares in w.h (trait
+ * `outOfClassMemberDefinitions`).
+ *
+ * The constructor family of a class is its in-class declarations; an
+ * out-of-class definition holds the body of exactly one of them. Linkage is
+ * by the owner's scope path, textual visibility of the class (same file or
+ * include closure) and the declaration's parameter signature. Anything less
+ * certain links nothing: the caller keeps its review result.
+ */
+
+const { langTraits } = require('../languages');
+
+const OWNER_KINDS = new Set(['class', 'struct', 'union']);
+
+const scopePath = def => [def.namespace, def.enclosingType].filter(Boolean).join('::');
+
+const outOfClassLanguage = (index, file) => !!langTraits(index.files.get(file)?.language)?.outOfClassMemberDefinitions;
+const applies = (index, def) => !!def?.className && outOfClassLanguage(index, def.file);
+
+function memo(index, name) {
+    return index.isProvenanceFactIndex ? null : index._opMemo?.(name, () => new WeakMap());
+}
+
+/** A definition outside every class body (its symbol's span lies in no owner). */
+function isOutOfClass(index, def) {
+    const { ownerDefinitionOf } = require('./class-identity');
+    return !def.isSignature && !ownerDefinitionOf(index, def);
+}
+
+/**
+ * The class an out-of-class constructor definition belongs to: the one
+ * class of its name whose scope path equals the definition's qualifier and
+ * that the definition's file sees. Null when none or several qualify.
+ */
+function definitionOwner(index, def) {
+    if (!applies(index, def) || !isOutOfClass(index, def)) return null;
+    const saved = memo(index, 'outOfClassOwner');
+    if (saved?.has(def)) return saved.get(def);
+    const visible = require('./cpp-scope').includeClosure(index, def.file);
+    const path = scopePath(def);
+    const owners = (index.symbols.get(def.className) || []).filter(owner => OWNER_KINDS.has(owner.type) &&
+        !owner.forwardDeclaration && scopePath(owner) === path && visible.has(owner.file));
+    const owner = owners.length === 1 ? owners[0] : null;
+    saved?.set(def, owner);
+    return owner;
+}
+
+/** The in-class constructor declaration an out-of-class definition defines. */
+function declarationOf(index, def) {
+    const owner = definitionOwner(index, def);
+    if (!owner) return null;
+    const { ownConstructors } = require('./constructor-calls');
+    const { _cFamilySignatureKey } = require('./callers');
+    const key = _cFamilySignatureKey(def);
+    const declared = ownConstructors(index, owner).filter(member => member.isSignature &&
+        _cFamilySignatureKey(member) === key);
+    return declared.length === 1 ? declared[0] : null;
+}
+
+/**
+ * The definition holding the body of an in-class constructor declaration:
+ * the declaration itself when it has a body, else its one linked
+ * out-of-class definition (null when there is none or several).
+ */
+function bodyDefinitionOf(index, declaration) {
+    if (!declaration?.isSignature || !applies(index, declaration)) return declaration;
+    const saved = memo(index, 'outOfClassBody');
+    if (saved?.has(declaration)) return saved.get(declaration);
+    const definitions = (index.symbols.get(declaration.name) || []).filter(def => def !== declaration &&
+        def.type === declaration.type && def.className === declaration.className && !def.isSignature &&
+        declarationOf(index, def) === declaration);
+    const body = definitions.length === 1 ? definitions[0] : null;
+    saved?.set(declaration, body);
+    return body;
+}
+
+/** The out-of-class constructor definition enclosing a call record of `file`. */
+function enclosingDefinition(index, file, call, owner) {
+    const enclosing = call.enclosingFunction;
+    if (!enclosing || !outOfClassLanguage(index, file)) return null;
+    const matches = (index.files.get(file)?.symbols || []).filter(def => def.name === owner.name &&
+        def.className === owner.name && !def.isSignature && def.startLine === enclosing.startLine &&
+        def.endLine === enclosing.endLine && require('./constructor-calls').isConstructor(def, index));
+    return matches.length === 1 && definitionOwner(index, matches[0]) === owner ? matches[0] : null;
+}
+
+/**
+ * Does a mem-initializer of an out-of-class constructor definition
+ * (parser `memberInitializer`) initialize a data member rather than
+ * construct a base (fix #421)? A name that is no project type, or a field
+ * of the definition's class, is a member; the record is then no call.
+ */
+function initializesMember(index, file, call, namesType) {
+    if (!call.memberInitializer) return false;
+    if (!namesType(call.name)) return true;
+    const enclosing = call.enclosingFunction;
+    if (!enclosing) return false;
+    const { isConstructor } = require('./constructor-calls');
+    const definitions = (index.files.get(file)?.symbols || []).filter(def => !def.isSignature &&
+        def.startLine === enclosing.startLine && def.endLine === enclosing.endLine && isConstructor(def, index));
+    const owner = definitions.length === 1 ? definitionOwner(index, definitions[0]) : null;
+    return !!owner && (index.symbols.get(call.name) || []).some(def => def.className === owner.name &&
+        def.file === owner.file && def.startLine >= owner.startLine && def.endLine <= owner.endLine &&
+        (def.type === 'field' || def.memberType === 'field'));
+}
+
+/**
+ * The project bases an out-of-class constructor definition leaves to
+ * implicit construction (fix #421): its class's written bases that none of
+ * its mem-initializers names, none when it delegates. `isProjectType(name)`
+ * keeps the bases the project declares.
+ */
+function omittedBases(index, def, isProjectType) {
+    const owner = definitionOwner(index, def);
+    if (!owner?.extends) return [];
+    const { getCachedCalls } = require('./callers');
+    const { splitParentList } = require('./graph-build');
+    const initializers = (getCachedCalls(index, def.file) || []).filter(call => call.constructorSyntax === 'delegation' &&
+        call.line >= def.startLine && call.line <= def.endLine &&
+        call.enclosingFunction?.startLine === def.startLine && call.enclosingFunction?.endLine === def.endLine);
+    if (initializers.some(call => call.ctorDelegation === 'this')) return [];
+    const initialized = new Set(initializers.map(call => call.name));
+    return splitParentList(owner.extends).map(spelling => {
+        const parts = String(spelling).replace(/<.*$/s, '').trim().split('::');
+        const name = parts.pop().trim();
+        return { name, qualifier: parts.join('::') || null };
+    }).filter(base => base.name && !initialized.has(base.name) && isProjectType(base.name));
+}
+
+/**
+ * Call records for the omitted base initializers of an out-of-class
+ * constructor definition (fix #421): the base's default constructor runs
+ * there, read from the class declaration in another place, so the site is
+ * a visible unverified candidate (`implicitOutOfClass`), never a confirmed
+ * edge.
+ */
+function implicitBaseRecords(index, def, isProjectType) {
+    if (!applies(index, def) || def.isSignature || !require('./constructor-calls').isConstructor(def, index)) return [];
+    const saved = memo(index, 'outOfClassImplicitBases');
+    if (saved?.has(def)) return saved.get(def);
+    const records = omittedBases(index, def, isProjectType).map(base => ({
+        name: base.name, line: def.startLine, isMethod: false, isConstructor: true,
+        constructorSyntax: 'implicit', argCount: 0, argKinds: [],
+        ...(base.qualifier && { constructorQualifier: base.qualifier }),
+        implicitOutOfClass: { owner: def.className },
+        enclosingFunction: { name: def.name, startLine: def.startLine, endLine: def.endLine, className: def.className },
+    }));
+    saved?.set(def, records);
+    return records;
+}
+
+/**
+ * The out-of-class constructor definitions of classes derived from `base`
+ * that construct it implicitly (fix #421), as unverified caller rows.
+ */
+function implicitBaseCallerRows(index, base, isProjectType) {
+    if (!outOfClassLanguage(index, base.file)) return [];
+    const rows = [];
+    const derived = new Set((index.extendedByGraph?.get(base.name) || [])
+        .map(child => typeof child === 'string' ? child : child.name));
+    for (const name of [...derived].sort()) {
+        for (const def of index.symbols.get(name) || []) {
+            if (def.className !== name || def.isSignature || !require('./constructor-calls').isConstructor(def, index)) continue;
+            const owner = definitionOwner(index, def);
+            if (!owner || !implicitBaseRecords(index, def, isProjectType).some(record => record.name === base.name)) continue;
+            // The derived class's written base must be this class.
+            const { resolveClassRef } = require('./class-identity');
+            const ref = resolveClassRef(index, base.name, owner.file);
+            if (ref?.def && ref.def !== base) continue;
+            rows.push(def);
+        }
+    }
+    return rows;
+}
+
+module.exports = { definitionOwner, declarationOf, bodyDefinitionOf, enclosingDefinition, initializesMember,
+    implicitBaseRecords, implicitBaseCallerRows };

package/core/output/analysis-ext.js

@@ -3,7 +3,7 @@
  */
 
 const { dynamicImportsNote, formatLineRanges, unverifiedReasonLabel, advisoryLine } = require('./shared');
-const { formatAccountLines, formatCalleeAccountLine, unverifiedCalleeLines } = require('./analysis');
+const { formatAccountLines, formatCalleeAccountLine, unverifiedCalleeLines, initializerReviewLines } = require('./analysis');
 
 /**
  * Format related command output - text
@@ -146,6 +146,7 @@ function formatSmart(smart, options = {}) {
     // v4 callee contract: unresolved calls inside the target — visible with
     // reasons (they may be dependencies smart could not inline).
     lines.push(...unverifiedCalleeLines(smart.unverifiedCallees, false));
+    lines.push(...initializerReviewLines(smart.initializerReviews, false));
     const smartCalleeAcct = formatCalleeAccountLine(smart.meta && smart.meta.calleeAccount);
     if (smartCalleeAcct) lines.push(`\n${smartCalleeAcct}`);
 
@@ -185,7 +186,8 @@ function formatSmartJson(result) {
             types: result.types || [],
             // v4 callee contract: visible unresolved-call entries, reconciled
             // by meta.calleeAccount.
-            unverifiedCallees: result.unverifiedCallees || []
+            unverifiedCallees: result.unverifiedCallees || [],
+            ...(result.initializerReviews?.length && { initializerReviews: result.initializerReviews }),
         }
     });
 }

package/core/output/analysis.js

@@ -222,6 +222,33 @@ function unverifiedCalleeLines(entries, compact) {
     return lines;
 }
 
+/**
+ * " (constructs X)" for a constructor body edge beside its class callee (fix
+ * #421); " (build alternative of F:L)" for a Go declaration of the callee in
+ * a file of another build constraint (fix #425).
+ */
+function constructsSuffix(callee) {
+    if (callee?.initializerOf) return ` (constructs ${callee.initializerOf})`;
+    return callee?.configurationAlternativeOf ? ` (build alternative of ${callee.configurationAlternativeOf})` : '';
+}
+
+/**
+ * Constructions whose class edge is confirmed while the constructor body
+ * they run is undecided (fix #421). Their sites are in the class edge's
+ * account; these lines say which body is not proven.
+ */
+function initializerReviewLines(entries, compact) {
+    if (!entries || entries.length === 0) return [];
+    const lines = [`${compact ? '' : '\n'}CONSTRUCTOR BODIES — UNDECIDED (${entries.length}) — class dependency confirmed above; which constructor runs is not proven:`];
+    for (const entry of entries) {
+        const candidates = entry.candidates > 1 ? ` (${entry.candidates} candidates)` : '';
+        const sites = entry.sites?.length ? ` L${entry.sites.join(',L')}` : '';
+        const label = entry.name === entry.initializerOf ? entry.name : `${entry.initializerOf}.${entry.name}`;
+        lines.push(`  ${label} ×${entry.callCount} — ${entry.reason}${candidates}${sites}`);
+    }
+    return lines;
+}
+
 /** "NON-CALL OCCURRENCES" summary line from the account. */
 function formatNonCallLine(account, hintName, usagesHint) {
     if (!account || !account.nonCall || account.nonCall.total === 0) return null;
@@ -388,11 +415,14 @@ function formatContextJson(context) {
                 ...(c.tier && { tier: c.tier }),
                 ...(c.sites && { sites: c.sites }),
                 ...(c.functionReference && { functionReference: true }),
+                ...(c.initializerOf && { initializerOf: c.initializerOf }),
+                ...(c.configurationAlternativeOf && { configurationAlternativeOf: c.configurationAlternativeOf }),
                 ...(c.reachable !== undefined && { reachable: c.reachable }),
             })),
             // v4 callee contract: visible unresolved-call entries (aggregated
             // name+reason), reconciled by meta.calleeAccount.
             unverifiedCallees: context.unverifiedCallees || [],
+            ...(context.initializerReviews?.length && { initializerReviews: context.initializerReviews }),
             ...(context.warnings && { warnings: context.warnings })
         }
     }, provenanceReplacer);
@@ -747,9 +777,9 @@ function formatContext(ctx, options = {}) {
         if (compact) {
             const snip = c.docstring ? calleeDocstringSnippet(c.docstring) : '';
             const docPart = snip ? `: ${snip}` : '';
-            lines.push(`  [${itemNum}] ${c.name}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${docPart}${unreachableMark}`);
+            lines.push(`  [${itemNum}] ${c.name}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${constructsSuffix(c)}${docPart}${unreachableMark}`);
         } else {
-            lines.push(`  [${itemNum}] ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${unreachableMark}`);
+            lines.push(`  [${itemNum}] ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${constructsSuffix(c)}${unreachableMark}`);
             if (c.docstring) {
                 const snip = calleeDocstringSnippet(c.docstring);
                 if (snip) lines.push(`    "${snip}"`);
@@ -770,6 +800,7 @@ function formatContext(ctx, options = {}) {
     // Unverified callee band (v4): aggregated name+reason entries — visible,
     // never silently dropped. Not expandable (no definition resolved).
     lines.push(...unverifiedCalleeLines(ctx.unverifiedCallees, compact));
+    lines.push(...initializerReviewLines(ctx.initializerReviews, compact));
 
     // Conservation contract lines: non-call summary + ACCOUNT/WARNING/FILTERED
     const account = ctx.meta && ctx.meta.account;
@@ -793,6 +824,38 @@ function formatContext(ctx, options = {}) {
 }
 
 /** Format impact command output - text. Shows what would need updating if a function signature changes. */
+/**
+ * The value band's token account (fix #420): every name token of the
+ * scanned lines is an access (confirmed, unverified, excluded by reason) or
+ * a declaration token.
+ */
+function formatValueAccount(name, band) {
+    const account = band.account;
+    const reasons = Object.entries(band.excluded?.byReason || {})
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, 4).map(([reason, count]) => `${reason} ${count}`).join(', ');
+    return `VALUE ACCOUNT: "${name}" is ${account.tokens} name token(s) on ${account.lines} line(s) in ` +
+        `${account.files} file(s): ${account.confirmed} confirmed, ${account.unverified} unverified, ` +
+        `${account.excluded} excluded${reasons ? ` (${reasons})` : ''}, ${account.declarations} declaration` +
+        `${account.textLines ? `; ${account.textLines} text-only line(s)` : ''}` +
+        `${account.conserved ? '' : ' [NOT CONSERVED]'}`;
+}
+
+function formatTypeAccount(name, band) {
+    const account = band.account;
+    const reasons = Object.entries(band.excluded?.byReason || {})
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, 4).map(([reason, count]) => `${reason} ${count}`).join(', ');
+    return `TYPE ACCOUNT: "${name}" is ${account.tokens} name token(s) on ${account.lines} line(s) in ` +
+        `${account.files} file(s): ${account.confirmed} confirmed, ${account.unverified} unverified, ` +
+        `${account.excluded} excluded${reasons ? ` (${reasons})` : ''}, ${account.constructions} at call sites, ` +
+        `${account.declarations} declaration` +
+        `${account.attributeTokens ? ` (${account.attributeTokens} attribute short name(s))` : ''}` +
+        `${account.unparsedLines ? `; ${account.unparsedLines} unparsed line(s)` : ''}` +
+        `${account.textLines ? `; ${account.textLines} text-only line(s)` : ''}` +
+        `${account.conserved ? '' : ' [NOT CONSERVED]'}`;
+}
+
 function formatImpact(impact, options = {}) {
     if (!impact) {
         return 'Function not found.';
@@ -814,8 +877,8 @@ function formatImpact(impact, options = {}) {
     // Summary (confirmed + unverified tiers reported separately)
     const impactUnverified = impact.unverifiedSites || [];
     const unverifiedSuffix = impactUnverified.length > 0 ? ` confirmed + ${impactUnverified.length} unverified` : '';
-    if (impact.propertyAccesses || impact.typeReferences) {
-        const pa = impact.propertyAccesses || impact.typeReferences;
+    if (impact.propertyAccesses || impact.valueAccesses || impact.typeReferences) {
+        const pa = impact.propertyAccesses || impact.valueAccesses || impact.typeReferences;
         const uv = pa.unverifiedCount ? ` + ${pa.unverifiedCount} unverified` : '';
         lines.push(`DEPENDENCY SITES: ${impact.totalDependencySites} confirmed${uv}`);
     }
@@ -891,9 +954,10 @@ function formatImpact(impact, options = {}) {
     }
     if (impactReach.note && !compact) lines.push(impactReach.note);
 
-    if (impact.propertyAccesses) {
-        const access = impact.propertyAccesses;
-        lines.push(`${compact ? '' : '\n'}PROPERTY ACCESS SITES: ${access.confirmedCount} confirmed` +
+    if (impact.propertyAccesses || impact.valueAccesses) {
+        const access = impact.propertyAccesses || impact.valueAccesses;
+        const label = impact.propertyAccesses ? 'PROPERTY' : 'VALUE';
+        lines.push(`${compact ? '' : '\n'}${label} ACCESS SITES: ${access.confirmedCount} confirmed` +
             (access.unverifiedCount ? ` + ${access.unverifiedCount} unverified` : ''));
         for (const group of access.byFile) {
             for (const site of group.sites) {
@@ -903,44 +967,47 @@ function formatImpact(impact, options = {}) {
             }
         }
         if (access.unverifiedSites.length > 0) {
-            lines.push(`${compact ? '' : '\n'}UNVERIFIED PROPERTY ACCESS CANDIDATES (${access.unverifiedSites.length}) — matching attribute syntax, receiver identity unresolved:`);
+            const reason = impact.propertyAccesses ? 'matching attribute syntax, receiver identity unresolved'
+                : 'matching value syntax, binding identity unresolved';
+            lines.push(`${compact ? '' : '\n'}UNVERIFIED ${label} ACCESS CANDIDATES (${access.unverifiedSites.length}) — ${reason}:`);
             for (const site of access.unverifiedSites.slice(0, 10)) {
                 const caller = site.callerName ? ` [${site.callerName}]` : '';
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${site.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}`);
+                const why = impact.valueAccesses && site.reason ? ` (${site.reason})` : '';
+                lines.push(`  ${site.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}${why}`);
             }
             if (access.unverifiedSites.length > 10) {
                 lines.push(`  (+${access.unverifiedSites.length - 10} more unverified)`);
             }
         }
+        const valueAccount = impact.valueAccesses?.account;
+        if (valueAccount) lines.push(formatValueAccount(impact.function, impact.valueAccesses));
     }
 
-    // fix #345: annotation sites of a type-kind definition, tiered like the
-    // accessor band. The headline no longer says 0 for a type with dependents.
+    // fixes #345, #428: the tokens naming a type outside its call sites,
+    // tiered by the type lookup, with their own account.
     if (impact.typeReferences) {
         const refs = impact.typeReferences;
         lines.push(`${compact ? '' : '\n'}TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed` +
-            (refs.unverifiedCount ? ` + ${refs.unverifiedCount} unverified` : '') +
-            (refs.excluded?.total ? ` (${refs.excluded.total} other-target)` : ''));
+            (refs.unverifiedCount ? ` + ${refs.unverifiedCount} unverified` : ''));
+        const position = site => `${site.kind || 'type'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}`;
         for (const group of refs.byFile) {
             for (const site of group.sites) {
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${group.file}:${site.line}${expr}`);
+                lines.push(`  ${group.file}:${site.line} [${position(site)}]${expr}`);
             }
         }
         if (refs.unverifiedSites.length > 0) {
-            lines.push(`${compact ? '' : '\n'}UNVERIFIED TYPE REFERENCE CANDIDATES (${refs.unverifiedSites.length}) — name matches, no import link to this definition:`);
+            lines.push(`${compact ? '' : '\n'}UNVERIFIED TYPE REFERENCE CANDIDATES (${refs.unverifiedSites.length}) — the name, the type lookup cannot decide what it names:`);
             for (const site of refs.unverifiedSites.slice(0, 10)) {
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${site.file}:${site.line}${expr} (${site.reason})`);
+                lines.push(`  ${site.file}:${site.line} [${position(site)}]${expr} (${site.reason})`);
             }
             if (refs.unverifiedSites.length > 10) {
                 lines.push(`  (+${refs.unverifiedSites.length - 10} more unverified)`);
             }
         }
-        if (refs.confirmedCount === 0 && refs.unverifiedCount === 0) {
-            lines.push('  (no annotation sites outside the definition)');
-        }
+        if (refs.account) lines.push(formatTypeAccount(impact.function, refs));
     }
 
     // Unverified tier: visible, capped at 10 one-liners
@@ -1132,7 +1199,7 @@ function formatAbout(about, options = {}) {
             const returnSuffix = c.returnType ? ` → ${c.returnType}` : '';
             const sideEffects = (c.sideEffects && c.sideEffects.length) ? ` {${c.sideEffects.join(',')}}` : '';
             const unreachableMark = (aboutCalleeReach.perLine && c.reachable === false) ? ' [unreachable]' : '';
-            lines.push(`  ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.file}:${c.line} (${c.callCount}x)${unreachableMark}`);
+            lines.push(`  ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.file}:${c.line} (${c.callCount}x)${constructsSuffix(c)}${unreachableMark}`);
             if (!compact && c.docstring) {
                 const snip = calleeDocstringSnippet(c.docstring);
                 if (snip) lines.push(`    "${snip}"`);
@@ -1261,4 +1328,6 @@ module.exports = {
     // Shared with output/analysis-ext.js (smart): single-node callee contract.
     formatCalleeAccountLine,
     unverifiedCalleeLines,
+    initializerReviewLines,
+    constructsSuffix,
 };

package/core/output/graph.js

@@ -443,8 +443,9 @@ function formatCircularDeps(result) {
         return lines.join('\n');
     }
 
-    const eager = result.cycles.filter(cycle => cycle.classification !== 'deferred');
+    const eager = result.cycles.filter(cycle => cycle.classification !== 'deferred' && cycle.classification !== 'static');
     const deferred = result.cycles.filter(cycle => cycle.classification === 'deferred');
+    const staticCycles = result.cycles.filter(cycle => cycle.classification === 'static');
 
     // Groups first: a strongly connected file set is the unit a refactor has
     // to break, and a 14-file tangle can hold hundreds of elementary cycles.
@@ -454,8 +455,12 @@ function formatCircularDeps(result) {
         lines.push(`CYCLE GROUPS (${groups.length}) — every member reaches every other member:`);
         for (const group of groups) {
             const counts = [];
-            if (group.eagerCycles != null) counts.push(`${group.eagerCycles} import-time`);
-            if (group.deferredCycles != null) counts.push(`${group.deferredCycles} deferred`);
+            // A group of files that run no module code on import has only
+            // static cycles; the import-time/deferred split does not apply.
+            const onlyStatic = group.staticCycles > 0 && !group.eagerCycles && !group.deferredCycles;
+            if (group.eagerCycles != null && !onlyStatic) counts.push(`${group.eagerCycles} import-time`);
+            if (group.deferredCycles != null && !onlyStatic) counts.push(`${group.deferredCycles} deferred`);
+            if (group.staticCycles > 0) counts.push(`${group.staticCycles} static`);
             const suffix = counts.length > 0 ? `  [${counts.join(', ')}${result.summary.truncated ? '; enumerated counts only' : ''}]` : '';
             lines.push(`  ${group.size} files: ${group.files.join(', ')}${suffix}`);
         }
@@ -489,6 +494,7 @@ function formatCircularDeps(result) {
     };
     renderGroup('IMPORT-TIME CYCLES', eager, false, EAGER_CYCLE_DISPLAY_LIMIT);
     renderGroup('DEFERRED CYCLES', deferred, true, DEFERRED_CYCLE_DISPLAY_LIMIT);
+    renderGroup('STATIC CYCLES', staticCycles, false, EAGER_CYCLE_DISPLAY_LIMIT);
 
     lines.push('');
     const { totalCycles, filesInCycles } = result.summary;
@@ -502,6 +508,9 @@ function formatCircularDeps(result) {
         }
         lines.push('The CYCLE GROUPS list and files-in-cycles count are complete; enumerated cycle counts are lower bounds.');
     }
+    if (staticCycles.length > 0) {
+        lines.push(`${staticCycles.length} chain${staticCycles.length === 1 ? ' links' : 's link'} only files whose imports and includes run no module code (Go, Rust, Java, C#, C, C++): static dependency cycles, not import-time cycles.`);
+    }
     if (deferred.length > 0) {
         lines.push(`${deferred.length} chain${deferred.length === 1 ? '' : 's'} close only through deferred edges (function-local, TYPE_CHECKING-only, or type-only imports); they are not unconditional import-time cycles, but a function-local edge may still matter if invoked during initialization.`);
     }

package/core/output/lines.js

@@ -244,15 +244,16 @@ function impactRecords(result) {
     }
     if (result.typeReferences) {
         const refs = result.typeReferences;
+        const where = site => `type-reference: ${site.kind || 'type'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}`;
         for (const group of refs.byFile || []) {
             for (const site of group.sites || []) {
-                out.push(record(group.file, site.line, site.expression, 'type-reference'));
+                out.push(record(group.file, site.line, site.expression, where(site)));
             }
         }
         for (const site of refs.unverifiedSites || []) {
-            out.push(record(pathOf(site), site.line, site.expression, `unverified: ${site.reason}; type-reference`));
+            out.push(record(pathOf(site), site.line, site.expression, `unverified: ${site.reason}; ${where(site)}`));
         }
-        notes.push(`# TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed, ${refs.unverifiedCount} unverified, ${refs.excluded?.total || 0} other-target (separate from caller ACCOUNT).`);
+        notes.push(`# TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed, ${refs.unverifiedCount} unverified, ${refs.excluded?.total || 0} excluded (separate from caller ACCOUNT).`);
     }
     notes.push(...accountComments(result.account));
     for (const warning of result.warnings || []) notes.push(...commentLines(warning.message));

package/core/output/public.js

@@ -410,6 +410,7 @@ function formatPublicJson(command, result, params = {}, execution = {}) {
         commandMeta.excludedDecorated = result.excludedDecorated || 0;
         commandMeta.excludedExternalContract = result.excludedExternalContract || 0;
         commandMeta.excludedRuntimeContract = result.excludedRuntimeContract || 0;
+        commandMeta.excludedConstructors = result.excludedConstructors || 0;
         commandMeta.pythonImplicitExportFiles = result.pythonImplicitExportFiles || 0;
         commandMeta.excludedDynamicDispatch = result.excludedDynamicDispatch || 0;
         commandMeta.computedDispatch = result.computedDispatch || { count: 0, names: [] };

package/core/output/reporting.js

@@ -214,8 +214,9 @@ function formatStatsJson(stats) {
 function formatDeadcode(results, options = {}) {
     if (results.length === 0 && !results.excludedDecorated &&
         !results.excludedExported && !results.excludedExternalContract &&
-        !results.excludedRuntimeContract && !results.pythonImplicitExportFiles &&
+        !results.excludedRuntimeContract && !results.excludedConstructors && !results.pythonImplicitExportFiles &&
         !results.excludedDynamicDispatch && !results.computedDispatch?.count &&
+        !results.reflection?.withheld && !results.reflection?.dynamicCount && !results.reflection?.literalCount &&
         results.coverage?.complete !== false) {
         return 'No dead code found.';
     }
@@ -291,6 +292,9 @@ function formatDeadcode(results, options = {}) {
     if (results.excludedRuntimeContract > 0) {
         lines.push(`\n${results.excludedRuntimeContract} runtime callback(s) hidden (language/runtime registrations, not dead).`);
     }
+    if (results.excludedConstructors > 0) {
+        lines.push(`\n${results.excludedConstructors} constructor(s) not listed: a constructor belongs to its type's allocation protocol, so the type is audited instead.`);
+    }
     if (results.pythonImplicitExportFiles > 0) {
         lines.push(`\nPython public-surface rule active in ${results.pythonImplicitExportFiles} file(s) without __all__: top-level non-underscore names are treated as externally reachable.`);
     }
@@ -366,6 +370,7 @@ function formatDeadcodeJson(results) {
             ...(results.excludedDecorated > 0 && { excludedDecorated: results.excludedDecorated }),
             ...(results.excludedExternalContract > 0 && { excludedExternalContract: results.excludedExternalContract }),
             ...(results.excludedRuntimeContract > 0 && { excludedRuntimeContract: results.excludedRuntimeContract }),
+            ...(results.excludedConstructors > 0 && { excludedConstructors: results.excludedConstructors }),
             ...(results.pythonImplicitExportFiles > 0 && { pythonImplicitExportFiles: results.pythonImplicitExportFiles }),
             ...(results.excludedDynamicDispatch > 0 && { excludedDynamicDispatch: results.excludedDynamicDispatch }),
             ...(results.computedDispatch?.count > 0 && { computedDispatch: results.computedDispatch }),

package/core/output/shared.js

@@ -177,6 +177,8 @@ function formatClassSignature(cls) {
     if (cls.implements && cls.implements.length > 0) {
         parts.push(`implements ${cls.implements.join(', ')}`);
     }
+    // `class State;` declares a class defined elsewhere (fix #427).
+    if (cls.forwardDeclaration) parts.push('(forward declaration)');
 
     return parts.join(' ');
 }