ucn 5.5.1 → 5.5.2

package/core/cpp-scope.js

@@ -23,7 +23,8 @@
  * Everything is memoized on the index (`_cppScope`) and reset at build/load.
  */
 
-const { codeUnitCompare } = require('./shared');
+const { codeUnitCompare, isValueDefinition, symbolsSpanning } = require('./shared');
+const { projectFact, sharedRead } = require('./provenance-overload');
 
 const TYPE_KINDS = new Set(['class', 'struct', 'union', 'enum', 'interface']);
 const MAX_ALIAS_HOPS = 8;
@@ -42,6 +43,19 @@ function _state(index) {
     return state;
 }
 
+// Source-derived conversion declarations share this build's invalidation.
+function conversionSyntaxMemo(index) {
+    const state = _state(index);
+    return state.conversionSyntax || (state.conversionSyntax = new Map());
+}
+
+// Live queries can reuse pure conversion results until index facts change.
+// Witness views recompute from their recorded raw declarations instead.
+function conversionResultMemo(index) {
+    const state = _state(index);
+    return state.conversionResults || (state.conversionResults = new Map());
+}
+
 function resetCppScope(index) {
     index._cppScope = null;
 }
@@ -50,22 +64,40 @@ function _isCppFile(index, file) {
     return index.files.get(file)?.language === 'cpp';
 }
 
+// Lookup consumes declaration inventories by kind. Record that raw subset
+// so a type or macro query does not copy unrelated same-name value members
+// into every overload witness. Scope and visibility still replay below.
+function _declarationsOfKind(index, name, kind) {
+    return projectFact(index, `cpp-${kind}-declarations:${name}`, live => {
+        const state = _state(live);
+        const memo = state.declarationKinds || (state.declarationKinds = new Map());
+        const key = `${kind}\0${name}`;
+        if (!memo.has(key)) memo.set(key, (live.symbols.get(name) || []).filter(definition => kind === 'macro'
+            ? definition.type === 'macro'
+            : _isCppFile(live, definition.file) && (TYPE_KINDS.has(definition.type) ||
+                definition.type === 'type' && definition.aliasOf)));
+        return memo.get(key);
+    });
+}
+
 /** Files a translation unit rooted at `file` sees through its includes. */
 function includeClosure(index, file) {
     const state = _state(index);
     if (!state.closures) state.closures = new Map();
     const cached = state.closures.get(file);
     if (cached) return cached;
-    const visible = new Set([file]);
-    const queue = [file];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        for (const imported of index.importGraph?.get(current) || []) {
-            if (visible.has(imported)) continue;
-            visible.add(imported);
-            queue.push(imported);
+    const visible = sharedRead(index, `cpp-include-closure:${file}`, view => {
+        const seen = new Set([file]);
+        const queue = [file];
+        for (let i = 0; i < queue.length; i++) {
+            for (const imported of view.importGraph?.get(queue[i]) || []) {
+                if (seen.has(imported)) continue;
+                seen.add(imported);
+                queue.push(imported);
+            }
         }
-    }
+        return seen;
+    });
     state.closures.set(file, visible);
     return visible;
 }
@@ -83,8 +115,8 @@ function _macroEffect(index, name, file) {
     const visible = includeClosure(index, file);
     let effect = null;
     let key = null;
-    for (const definition of index.symbols.get(name) || []) {
-        if (definition.type !== 'macro' || !visible.has(definition.file)) continue;
+    for (const definition of _declarationsOfKind(index, name, 'macro')) {
+        if (!visible.has(definition.file)) continue;
         const scope = definition.namespaceScope;
         const scopeKey = scope ? JSON.stringify(scope) : '';
         if (key === null) {
@@ -113,8 +145,8 @@ function _macroEffect(index, name, file) {
 function _expandedNamespaceName(index, name, visible, depth = 0) {
     if (depth > 4) return [name];
     let body = null;
-    for (const definition of index.symbols.get(name) || []) {
-        if (definition.type !== 'macro' || !visible.has(definition.file)) continue;
+    for (const definition of _declarationsOfKind(index, name, 'macro')) {
+        if (!visible.has(definition.file)) continue;
         if (Array.isArray(definition.ppParams) || typeof definition.ppBody !== 'string') return [name];
         const text = definition.ppBody.replace(/\s+/g, '');
         if (!/^[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*$/.test(text)) return [name];
@@ -134,6 +166,17 @@ function _expandedNamespaceName(index, name, visible, depth = 0) {
 function _filePrefixes(index, file) {
     const state = _state(index);
     if (state.filePrefixes.has(file)) return state.filePrefixes.get(file);
+    // Every witness of an operation reads a file's macro scopes alike: a
+    // capture derives them once and records that derivation's reads (fix
+    // #435: each type-lookup capture re-derived them).
+    const transitions = index.isProvenanceFactIndex && typeof index.sharedRead === 'function'
+        ? index.sharedRead(`cpp-file-prefixes\0${file}`, view => _filePrefixesUncached(view, file))
+        : _filePrefixesUncached(index, file);
+    state.filePrefixes.set(file, transitions);
+    return transitions;
+}
+
+function _filePrefixesUncached(index, file) {
     const entry = index.files.get(file);
     const markers = entry?.macroScopeMarkers || [];
     let transitions = [];
@@ -151,7 +194,6 @@ function _filePrefixes(index, file) {
         for (const group of effect.opens || []) stack.push(group);
         transitions.push({ line: marker.line, prefix: stack.flat().join('::') });
     }
-    state.filePrefixes.set(file, transitions);
     return transitions;
 }
 
@@ -177,13 +219,15 @@ function effectiveNamespace(index, definition) {
 /** Effective namespace enclosing an arbitrary source position. */
 function namespaceAt(index, file, line) {
     const prefix = _macroPrefixAt(index, file, line);
-    const entry = index.files.get(file);
     let own = '';
     let ownSpan = Infinity;
     // The innermost definition containing the line carries the AST
     // namespace of that position.
-    for (const symbol of entry?.symbols || []) {
-        if (symbol.startLine > line || symbol.endLine < line) continue;
+    const enclosing = projectFact(index, `cpp-namespace-spans:${file}:${line}`, live =>
+        symbolsSpanning(live.files.get(file)?.symbols, line).map(symbol => ({
+            startLine: symbol.startLine, endLine: symbol.endLine, namespace: symbol.namespace,
+        })));
+    for (const symbol of enclosing) {
         const span = symbol.endLine - symbol.startLine;
         if (span < ownSpan) {
             ownSpan = span;
@@ -193,23 +237,41 @@ function namespaceAt(index, file, line) {
     return prefix && own ? `${prefix}::${own}` : prefix || own;
 }
 
-function _inventory(index) {
-    const state = _state(index);
-    if (state.inventory) return state.inventory;
-    const namespaces = new Set();
+function* _namespaceInventory(index, namespaces) {
     for (const entry of index.files.values()) {
         if (entry.language !== 'cpp') continue;
         for (const symbol of entry.symbols || []) {
             const namespace = effectiveNamespace(index, symbol);
-            if (!namespace) continue;
+            if (!namespace || namespaces.has(namespace)) continue;
             const parts = namespace.split('::');
             for (let i = 1; i <= parts.length; i++) {
-                namespaces.add(parts.slice(0, i).join('::'));
+                yield parts.slice(0, i).join('::');
             }
         }
     }
-    state.inventory = namespaces;
-    return namespaces;
+}
+
+function _hasNamespace(index, namespace) {
+    // A witness records the answer, never the project-wide inventory (fix #418).
+    if (index.isProvenanceFactIndex) {
+        return projectFact(index, `cpp-namespace:${namespace}`, live => _hasNamespace(live, namespace));
+    }
+    const state = _state(index);
+    if (!state.inventory) state.inventory = new Set();
+    if (state.inventory.has(namespace)) return true;
+    if (state.inventoryComplete) return false;
+    if (!state.inventoryScan) state.inventoryScan = _namespaceInventory(index, state.inventory);
+    // A successful lookup needs only the prefix it found. Keep the scan
+    // position so later lookups can discover every remaining namespace.
+    let next;
+    while (!(next = state.inventoryScan.next()).done) {
+        const name = next.value;
+        state.inventory.add(name);
+        if (name === namespace) return true;
+    }
+    state.inventoryComplete = true;
+    state.inventoryScan = null;
+    return false;
 }
 
 /** Remove template argument lists (depth-aware) and whitespace. */
@@ -271,10 +333,7 @@ function _scopeOf(index, definition) {
 }
 
 function _typeCandidates(index, name) {
-    return (index.symbols.get(name) || []).filter(definition =>
-        _isCppFile(index, definition.file) &&
-        (TYPE_KINDS.has(definition.type) ||
-         (definition.type === 'type' && definition.aliasOf)));
+    return _declarationsOfKind(index, name, 'type');
 }
 
 /**
@@ -287,6 +346,10 @@ function _usingsInScope(index, context, visibleFiles) {
     const take = (file, fact) => {
         if (file === context.file) {
             if (fact.line > context.line) return;
+            if (fact.ppGroups?.some(group => {
+                const branch = _branchAt(group, context.line);
+                return branch >= 0 && branch !== _branchAt(group, fact.line);
+            })) return;
             if (fact.scopeStartLine != null &&
                 (context.line < fact.scopeStartLine || context.line > fact.scopeEndLine)) return;
         } else if (fact.scopeStartLine != null) {
@@ -309,6 +372,80 @@ function _usingsInScope(index, context, visibleFiles) {
     return out;
 }
 
+function _branchAt(group, line) {
+    return Number.isInteger(line) ? group.branches.findIndex(([start, end]) =>
+        start <= line && line <= end) : -1;
+}
+
+/** An import and a local declaration can bind one name in different builds. */
+function _conditionalImports(index, definition) {
+    if (!definition?.file || definition.className || definition.receiver || definition.enclosingType ||
+        definition.type === 'macro') return [];
+    const facts = index.files.get(definition.file)?.cppUsings;
+    if (!facts?.some(fact => fact.name === definition.name && fact.ppGroups?.length)) return [];
+    const state = _state(index);
+    state.conditionalImports ||= new WeakMap();
+    if (state.conditionalImports.has(definition)) return state.conditionalImports.get(definition);
+    const namespace = effectiveNamespace(index, definition);
+    const out = [];
+    // Qualifier lookup can revisit this declaration through a namespace alias.
+    state.conditionalImports.set(definition, out);
+    for (const raw of facts) {
+        if (!['declaration', 'namespace-alias'].includes(raw.kind) ||
+            raw.name !== definition.name || raw.scopeStartLine != null) continue;
+        const groups = (raw.ppGroups || []).filter(group => {
+            const branch = _branchAt(group, definition.startLine);
+            return branch >= 0 && branch !== _branchAt(group, raw.line);
+        });
+        if (groups.length === 0 || effectiveNamespace(index,
+            { file: definition.file, startLine: raw.line, namespace: raw.namespace }) !== namespace) continue;
+        if (raw.kind === 'namespace-alias') {
+            out.push({ groups });
+            continue;
+        }
+        const fact = _withExpandedTarget(index, { ...raw, file: definition.file });
+        const qualifier = fact.target.replace(/^::/, '').split('::').slice(0, -1).join('::');
+        const supplier = resolveQualifier(index, _factContext(index, fact, definition.file),
+            qualifier, includeClosure(index, definition.file));
+        if (supplier.kind === 'namespace' &&
+            (supplier.resolvedNamespace || supplier.namespace) === namespace) continue;
+        out.push({ groups });
+    }
+    state.conditionalImports.set(definition, out);
+    return out;
+}
+
+/** null: unchanged binding; other: absent here; uncertain: build selects it. */
+function conditionalImportBinding(index, definitions, site) {
+    let affected = false;
+    let allOther = true;
+    for (const definition of definitions) {
+        const imports = _conditionalImports(index, definition);
+        // The import alternatives live in the definition's file: a
+        // translation unit that cannot include it reaches the definition
+        // by linkage alone, whatever that file's configuration (fix #419).
+        if (imports.length === 0 || site.file !== definition.file &&
+            require('./callers')._cppTargetVisibility(index, site.file, [definition]) === 'no') {
+            allOther = false;
+            continue;
+        }
+        affected = true;
+        let other = false;
+        let unknown = false;
+        for (const item of imports) for (const group of item.groups) {
+            const branch = site.file === definition.file ? _branchAt(group, site.line) : -1;
+            if (branch < 0) unknown = true;
+            else if (branch !== _branchAt(group, definition.startLine)) other = true;
+        }
+        // One known incompatible branch excludes this definition even if
+        // an outer or nested condition remains unknown.
+        if (other) continue;
+        allOther = false;
+        if (!unknown) return null;
+    }
+    return affected ? (allOther ? 'other' : 'uncertain') : null;
+}
+
 /**
  * A using fact whose target spells a namespace through an object-like macro
  * (`using namespace LIB_NAMESPACE;`, `using LIB_NAMESPACE::f;`) names what
@@ -323,7 +460,7 @@ function _withExpandedTarget(index, fact) {
     if (segments.some(part => !/^[A-Za-z_]\w*$/.test(part))) return fact;
     const keepLast = fact.kind === 'declaration' && segments.length > 1;
     const head = keepLast ? segments.slice(0, -1) : segments;
-    if (!head.some(part => (index.symbols.get(part) || []).some(definition => definition.type === 'macro'))) {
+    if (!head.some(part => _declarationsOfKind(index, part, 'macro').length)) {
         return fact;
     }
     const visible = includeClosure(index, fact.file);
@@ -379,6 +516,7 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
     // for the last segment (a class, or a typedef/alias of that spelling)
     // instead of the classes an alias denotes.
     const declarationsOnly = options.declarations === true;
+    const values = declarationsOnly && options.values === true;
     const plain = stripTemplateArguments(spelling);
     const global = plain.startsWith('::');
     let segments = plain.replace(/^::/, '').split('::').filter(Boolean);
@@ -389,14 +527,14 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
     // (`LIB_NAMESPACE::detail::X`) is the name the macro expands to, as in
     // macro-opened namespaces (fix #396).
     if (segments.length > 1 && visibleFiles && segments.slice(0, -1).some(part =>
-        (index.symbols.get(part) || []).some(definition => definition.type === 'macro'))) {
+        _declarationsOfKind(index, part, 'macro').length)) {
         segments = [...segments.slice(0, -1).flatMap(part => _expandedNamespaceName(index, part, visibleFiles)),
             segments[segments.length - 1]];
     }
     if (depth > MAX_ALIAS_HOPS) return { kind: 'unknown', why: 'alias-depth' };
     const origin = context.origin || context.file;
     const cacheKey = `${origin}\0${context.file}\0${context.line}\0${context.className || ''}\0${plain}` +
-        `${declarationsOnly ? '\0d' : ''}${context.namespace != null ? `\0ns:${context.namespace}` : ''}`;
+        `${declarationsOnly ? '\0d' : ''}${options.externalTypes ? '\0external' : ''}${values ? `\0v:${options.valueSite?.index ?? ''}` : ''}${context.namespace != null ? `\0ns:${context.namespace}` : ''}`;
     const state = _state(index);
     if (state.resolved.has(cacheKey)) return state.resolved.get(cacheKey);
     const finish = result => {
@@ -415,9 +553,28 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
     const introducers = usings.filter(fact =>
         (fact.kind === 'declaration' || fact.kind === 'namespace-alias') &&
         fact.name === segments[0]);
+    if (introducers.some(fact => fact.ppGroups?.length > 0)) {
+        const scopes = new Set(_enclosingPrefixes(contextNamespace));
+        const local = (index.symbols.get(segments[0]) || []).filter(definition =>
+            visibleFiles?.has(definition.file) && scopes.has(effectiveNamespace(index, definition)));
+        if (conditionalImportBinding(index, local, context) === 'uncertain') {
+            return finish({ kind: 'unknown', why: 'configuration-alternative' });
+        }
+    }
     if (introducers.length > 0) {
         const targets = new Set(introducers.map(fact => fact.target));
-        if (targets.size !== 1) return finish({ kind: 'unknown', why: 'ambiguous-using' });
+        if (targets.size !== 1) {
+            // Different namespace aliases leave identity undecided while
+            // still proving the qualifier cannot name a class. A type
+            // alternative keeps even that category uncertain.
+            const scopes = new Set(_enclosingPrefixes(contextNamespace));
+            const localTypes = _typeCandidates(index, segments[0]).some(definition =>
+                visibleFiles?.has(definition.file) && scopes.has(effectiveNamespace(index, definition)));
+            const namespaceOnly = segments.length === 1 && !localTypes &&
+                introducers.every(fact => fact.kind === 'namespace-alias');
+            return finish({ kind: 'unknown', why: 'ambiguous-using',
+                ...(namespaceOnly && { namespaceOnly: true }) });
+        }
         const fact = introducers[0];
         const rewritten = [fact.target, ...segments.slice(1)].join('::');
         return finish(resolveQualifier(index, _factContext(index, fact, origin),
@@ -452,29 +609,67 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
             if (!scopes.includes(full)) scopes.push(full);
         }
     }
-    const candidates = _typeCandidates(index, name);
+    const enumScopes = new Map();
+    const candidates = values ? (index.symbols.get(name) || []).filter(definition => {
+        if (!_isCppFile(index, definition.file) || !isValueDefinition(definition)) return false;
+        const info = require('./value-references').enumValueBindingInfo(index, definition);
+        if (info?.scope?.type === 'field_declaration_list') return false;
+        if (!definition.className) return true;
+        const owner = info?.unscoped && require('./class-identity').ownerRefOf(index, definition);
+        if (!owner?.def) return false;
+        const local = info.scope && !['translation_unit', 'field_declaration_list'].includes(info.scope.type);
+        if (local && (options.valueSite?.file !== definition.file ||
+            info.scope.startIndex > options.valueSite.index || info.scope.endIndex <= options.valueSite.index)) return false;
+        enumScopes.set(definition, { definition: owner.def, ...(local && { scope: info.scope }) });
+        return true;
+    })
+        : _typeCandidates(index, name);
     let matched = [];
     // Innermost scope wins (C++ unqualified and qualified lookup both stop
     // at the first scope that declares the name).
     for (const scope of scopes) {
         const want = _join(scope, qualifier);
         matched = candidates.filter(definition => {
-            if (_scopeOf(index, definition) !== want) return false;
+            const declared = enumScopes.get(definition)?.definition || definition;
+            if (_scopeOf(index, declared) !== want) return false;
             // Block-scope aliases are visible only inside their own block.
-            if (definition.lexicalScopeStartLine != null &&
-                definition.lexicalScopeEndLine != null &&
-                !(definition.type === 'type' && definition.enclosingType)) {
-                return definition.file === context.file &&
-                    definition.lexicalScopeStartLine <= context.line &&
-                    context.line <= definition.lexicalScopeEndLine;
+            if (declared.lexicalScopeStartLine != null &&
+                declared.lexicalScopeEndLine != null &&
+                !(declared.type === 'type' && declared.enclosingType)) {
+                return declared.file === context.file &&
+                    declared.lexicalScopeStartLine <= context.line &&
+                    context.line <= declared.lexicalScopeEndLine;
             }
             return true;
         });
         if (matched.length > 0) break;
     }
+    const localEnums = matched.filter(definition => enumScopes.get(definition)?.scope);
+    if (localEnums.length) {
+        const width = definition => {
+            const scope = enumScopes.get(definition).scope;
+            return scope.endIndex - scope.startIndex;
+        };
+        const closest = Math.min(...localEnums.map(width));
+        matched = localEnums.filter(definition => width(definition) === closest);
+    }
     if (matched.length === 0) {
         const full = segments.join('::');
-        const scope = scopes.find(candidate => _inventory(index).has(_join(candidate, full)));
+        // Platform type facts are usable only after ordinary name lookup.
+        // A local namespace/type called std shadows the global root, and
+        // conditional imports cannot establish a platform identity.
+        if (options.externalTypes && !usings.some(fact => fact.ppGroups?.length)) {
+            const shadowed = !global && segments.length > 1 &&
+                _enclosingPrefixes(contextNamespace).filter(Boolean).some(prefix => {
+                    const first = _join(prefix, segments[0]);
+                    return _hasNamespace(index, first) || _typeCandidates(index, segments[0])
+                        .some(definition => visibleFiles?.has(definition.file) && _scopeOf(index, definition) === prefix);
+                });
+            const external = !shadowed && scopes.map(scope => _join(scope, full))
+                .find(name => name.startsWith('std::'));
+            if (external) return finish({ kind: 'external', qualified: external });
+        }
+        const scope = scopes.find(candidate => _hasNamespace(index, _join(candidate, full)));
         if (scope !== undefined) {
             // `resolvedNamespace` (fix #393): the namespace the spelling
             // names from this scope (innermost first).
@@ -492,8 +687,11 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
         return finish({ kind: 'unknown', why: 'not-visible' });
     }
     const chosen = visible.length > 0 ? visible : matched;
+    if (conditionalImportBinding(index, chosen, context)) {
+        return finish({ kind: 'unknown', why: 'configuration-alternative' });
+    }
     if (declarationsOnly) {
-        return finish({ kind: 'type', declarations: chosen, visible: visible.length > 0 });
+        return finish({ kind: values ? 'value' : 'type', declarations: chosen, visible: visible.length > 0 });
     }
     const classes = [];
     for (const definition of chosen) {
@@ -520,6 +718,9 @@ function resolveQualifier(index, context, spelling, visibleFiles, depth = 0, opt
 }
 
 module.exports = {
+    conversionSyntaxMemo,
+    conversionResultMemo,
+    conditionalImportBinding,
     macroPrefixAt: _macroPrefixAt,
     globalQualifiedReaches,
     resetCppScope,

package/core/deadcode.js

@@ -15,7 +15,7 @@ const { splitParentList } = require('./graph-build');
 const { isOverrideMarked, codeUnitCompare, lineInRanges, maskBlockComments, escapeRegExp } = require('./shared');
 const { projectComputedDispatch, projectReflectionSites } = require('./ast-analysis');
 const { reflectionPatternReferences } = require('./reflection');
-const { protocolMemberOf, protocolTypeOf, typedLiteralContract } = require('./contract-membership');
+const { protocolMemberOf, protocolTypeOf, typedLiteralContract, rustProjectTraits } = require('./contract-membership');
 
 const _CLASS_KINDS = ['class', 'struct', 'interface', 'trait', 'record'];
 
@@ -212,6 +212,13 @@ function _classHasExternalBase(index, symbol) {
  */
 function overridesOutOfTreeBase(index, symbol) {
     if (!symbol.className) return false; // standalone function can't override
+    // A member that names its contract (Rust `impl Trait for X`, fix #422):
+    // the trait's identity decides, not the number of same-name owners. Two
+    // project types implementing one external trait (`FromIterator`) are
+    // each reached through it (`.collect::<A>()`), the impls being owners
+    // of nothing the project declares.
+    if (symbol.traitName &&
+        rustProjectTraits(index, symbol.traitName, symbol.file, symbol.startLine).length === 0) return true;
     if (isOverrideMarked(symbol)) {
         const owners = (index.symbols.get(symbol.name) || []).filter(s => s.className);
         if (owners.length <= 1) return true;
@@ -481,7 +488,7 @@ function buildUsageIndex(index, filterNames) {
 
     for (const [filePath, fileEntry] of index.files) {
         try {
-            const language = detectLanguage(filePath);
+            const language = fileEntry.language || detectLanguage(filePath, index.root);
             if (!language) continue;
 
             const content = index._readFile(filePath);
@@ -745,6 +752,7 @@ function deadcode(index, options = {}) {
     let excludedExported = 0;
     let excludedExternalContract = 0;
     let excludedRuntimeContract = 0;
+    let excludedConstructors = 0;
     let excludedDynamicDispatch = 0;
     const computedDispatchByFile = projectComputedDispatch(index);
     const computedDispatchReceivers = new Set();
@@ -1164,8 +1172,10 @@ function deadcode(index, options = {}) {
                                     // base definition this syntax consumes.
                                     dottedScope = undefined;
                                 } else {
+                                    // The receiver is a binding's local name
+                                    // (fix #424: `from pkg import sub as x`).
                                     const binding = (fileEntry.importBindings || [])
-                                        .find(b => b.name === receiver);
+                                        .find(b => (b.alias || b.name) === receiver);
                                     let resolved;
                                     if (binding && fileEntry.moduleResolved) {
                                         // `from . import types` binds the
@@ -1178,7 +1188,7 @@ function deadcode(index, options = {}) {
                                         // to the file that actually owns them.
                                         const mod = String(binding.module);
                                         const submodule = mod.endsWith('.')
-                                            ? mod + receiver : mod + '.' + receiver;
+                                            ? mod + binding.name : mod + '.' + binding.name;
                                         resolved = fileEntry.moduleResolved[submodule] ||
                                             fileEntry.moduleResolved[mod];
                                     }
@@ -1346,6 +1356,13 @@ function deadcode(index, options = {}) {
             if (symbol.relativePath.endsWith('.d.ts')) {
                 continue;
             }
+            // The same holds for a `declare global` / `declare module 'x'`
+            // block in a source file (fix #423): its declarations merge
+            // with declarations outside the project, whose readers UCN
+            // cannot see (`interface Window`, a library's `Register`).
+            if (symbol.ambientAugmentation) {
+                continue;
+            }
 
             // Language-specific entry points (called by runtime/test runner, not user code)
             // Each language module declares its own isEntryPoint() rules.
@@ -1353,6 +1370,19 @@ function deadcode(index, options = {}) {
             if (langModule.isEntryPoint?.(symbol)) {
                 continue;
             }
+            // A constructor participates in the type's allocation protocol,
+            // including reflective/framework construction and the implicit
+            // initializer that deleting it may introduce. A zero name count
+            // cannot establish that this declaration is independently dead.
+            // Ordinary methods with a constructor-like name remain auditable.
+            // Counted apart from runtime callbacks (fix #421): the type is
+            // audited instead, its constructors are not claims of their own.
+            if (symbol.type === 'constructor' ||
+                (symbol.className && !classAuditSet.has(symbol.type) &&
+                    langTraits(lang)?.constructorProtocol?.initializer === name)) {
+                excludedConstructors++;
+                continue;
+            }
             // Members the runtime/compiler invokes by name (trait
             // languageProtocolMember): Java serialization callbacks on
             // Serializable types, Python Enum hooks on Enum subclasses, C#
@@ -1413,17 +1443,6 @@ function deadcode(index, options = {}) {
             if (index.calleeIndex.has(name) && !selfRecursiveNames.has(name)) {
                 continue;
             }
-            // Constructor members are invoked through the CLASS name
-            // (fix #239, G2-js-measured: `new Widget()` indexes under
-            // 'Widget' — the member lookup claimed every instantiated
-            // class's constructor dead).
-            if (symbol.className &&
-                (symbol.type === 'constructor' || name === 'constructor' || name === '__init__') &&
-                index.calleeIndex.has(symbol.className) &&
-                !selfRecursiveNames.has(symbol.className)) {
-                continue;
-            }
-
             // Class-kind claims (fix #253a): a class whose member the runtime
             // or a framework invokes is live with zero textual references of
             // the class NAME — `class Main { public static void main }`,
@@ -1613,6 +1632,7 @@ function deadcode(index, options = {}) {
     results.excludedExported = excludedExported;
     results.excludedExternalContract = excludedExternalContract;
     results.excludedRuntimeContract = excludedRuntimeContract;
+    results.excludedConstructors = excludedConstructors;
     results.excludedDynamicDispatch = excludedDynamicDispatch;
     results.computedDispatch = computedDispatchInfo;
     reflectionInfo.withheldByPattern = [...reflectionWithheldByPattern]