ucn 5.4.1 → 5.5.0

package/core/provenance-facts.js

@@ -6,6 +6,7 @@ const { NON_CALLABLE_TYPES } = require('./shared');
 const { declarationIdentity, identityKey, propertyReadMember } = require('./provenance');
 const { captureOverload, overloadMemberGroup } = require('./provenance-overload');
 const { splitParentList } = require('./graph-build');
+const { distinctOwnerDefinitions } = require('./class-identity');
 
 const TYPE_KINDS = new Set(['class', 'struct', 'interface', 'trait', 'record', 'enum', 'type', 'impl']);
 const ownerName = definition => definition.className || (definition.receiver || '').replace(/^\*/, '');
@@ -24,6 +25,72 @@ function occurrenceIdentity(file, call, siteId) {
     };
 }
 
+/**
+ * Callable same-name definitions owned by a type, in symbol-table order.
+ * Within an operation the name's definitions are grouped once (fix #382):
+ * an exact HOT ranking resolves every site of a name once per same-name
+ * definition, and a filter over thousands of definitions per site made the
+ * ranking quadratic.
+ */
+function callableMembersOwnedBy(index, name, owner) {
+    const definitions = index.symbols.get(name) || [];
+    const memo = index._opMemo?.('callableMembersByOwner', () => new WeakMap());
+    if (!memo) {
+        return definitions.filter(d => !NON_CALLABLE_TYPES.has(d.type) && ownerName(d) === owner);
+    }
+    let byOwner = memo.get(definitions);
+    if (!byOwner) {
+        byOwner = new Map();
+        for (const d of definitions) {
+            if (NON_CALLABLE_TYPES.has(d.type)) continue;
+            const key = ownerName(d);
+            let list = byOwner.get(key);
+            if (!list) {
+                list = [];
+                byOwner.set(key, list);
+            }
+            list.push(d);
+        }
+        memo.set(definitions, byOwner);
+    }
+    return byOwner.get(owner) || [];
+}
+
+/** Same-name definitions declared in one file, in symbol-table order. */
+function definitionsInFile(index, name, file) {
+    const definitions = index.symbols.get(name) || [];
+    const memo = index._opMemo?.('definitionsByFile', () => new WeakMap());
+    if (!memo) return definitions.filter(d => d.file === file);
+    let byFile = memo.get(definitions);
+    if (!byFile) {
+        byFile = new Map();
+        for (const d of definitions) {
+            let list = byFile.get(d.file);
+            if (!list) {
+                list = [];
+                byFile.set(d.file, list);
+            }
+            list.push(d);
+        }
+        memo.set(definitions, byFile);
+    }
+    return byFile.get(file) || [];
+}
+
+/** The first same-name definition in a file starting at `line`, if any. */
+function definitionAt(index, name, file, line) {
+    const inFile = definitionsInFile(index, name, file);
+    const memo = index._opMemo?.('definitionsByLine', () => new WeakMap());
+    if (!memo || inFile.length < 8) return inFile.find(d => d.startLine === line);
+    let byLine = memo.get(inFile);
+    if (!byLine) {
+        byLine = new Map();
+        for (const d of inFile) if (!byLine.has(d.startLine)) byLine.set(d.startLine, d);
+        memo.set(inFile, byLine);
+    }
+    return byLine.get(line);
+}
+
 /** Follow paired AST import/export names; an arbitrary file import is no hop. */
 function namedDeclaration(index, file, name, accepts, line, seen = new Set()) {
     const key = `${file}\0${name}`;
@@ -45,7 +112,7 @@ function namedDeclaration(index, file, name, accepts, line, seen = new Set()) {
             }, ...result.chain] };
         }
     }
-    let local = (index.symbols.get(name) || []).filter(d => d.file === file && accepts(d));
+    let local = definitionsInFile(index, name, file).filter(d => accepts(d));
     if (line != null) {
         local = local.filter(d => !d.lexicalScopeStartLine ||
             (line >= d.lexicalScopeStartLine && line <= d.lexicalScopeEndLine));
@@ -101,6 +168,23 @@ function namedDeclaration(index, file, name, accepts, line, seen = new Set()) {
     return distinct.size === 1 ? distinct.values().next().value : null;
 }
 
+// Distinct owners of a member name. Depends only on the symbol table, so
+// one operation (a findCallers pass visits every call site of the name)
+// computes it once per name; the memo dies with the operation's content cache.
+const ownerCountMemo = new WeakMap(); // op content cache -> Map<name, count>
+function ownerCountOf(index, name) {
+    const scope = index._opContentCache;
+    let memo = scope ? ownerCountMemo.get(scope) : null;
+    if (scope && !memo) { memo = new Map(); ownerCountMemo.set(scope, memo); }
+    const cached = memo?.get(name);
+    if (cached !== undefined) return cached;
+    const count = new Set((index.symbols.get(name) || [])
+        .filter(d => !NON_CALLABLE_TYPES.has(d.type) && ownerName(d))
+        .map(d => `${d.file}\0${ownerName(d)}\0${d.namespace || ''}`)).size;
+    memo?.set(name, count);
+    return count;
+}
+
 /** Collect independent facts; a failed lookup never manufactures a negative. */
 function confirmationFacts(index, file, call, targets, options = {}) {
     const entry = index.files.get(file);
@@ -114,9 +198,7 @@ function confirmationFacts(index, file, call, targets, options = {}) {
         receiverTypeSource: options.receiverTypeSource || call.receiverTypeSource || 'unknown',
         receiverOrigin: options.receiverOrigin || call.receiverTypeEvidence || null,
         ...(call.isFunctionReference && { valueReference: true }),
-        ownerCount: new Set((index.symbols.get(call.name) || [])
-            .filter(d => !NON_CALLABLE_TYPES.has(d.type) && ownerName(d))
-            .map(d => `${d.file}\0${ownerName(d)}\0${d.namespace || ''}`)).size,
+        ownerCount: ownerCountOf(index, call.name),
         ...((options.originFile || call.receiverTypeFlowFile) && {
             receiverTypeFlowFile: path.relative(index.root, options.originFile || call.receiverTypeFlowFile),
         }),
@@ -141,13 +223,13 @@ function confirmationFacts(index, file, call, targets, options = {}) {
     }
     let type = facts.receiverType;
     if (options.sameClass) {
-        const enclosing = index.findEnclosingFunction(file, call.line, true);
+        const enclosing = index.findEnclosingFunction(file, call.line, true, call);
         type = enclosing?.className || enclosing?.receiver?.replace(/^\*/, '');
         facts.receiverTypeSource = 'same-class';
         facts.receiverOrigin = { source: 'same-class', declaration: declarationIdentity(enclosing) };
     }
     if (language === 'csharp' && call.receiverCastThis) {
-        const enclosing = index.findEnclosingFunction(file, call.line, true);
+        const enclosing = index.findEnclosingFunction(file, call.line, true, call);
         if (enclosing?.className) {
             facts.receiverCastThis = { enclosing: declarationIdentity(enclosing), interfaceType: type };
             type = enclosing.className;
@@ -188,10 +270,13 @@ function confirmationFacts(index, file, call, targets, options = {}) {
     // already-pinned declaration file may be another crate/module, where
     // replaying `crate::Type` or an import alias would change its meaning.
     const receiverContext = qualifier && facts.receiverTypeSource === 'annotation' ? file : originFile;
-    let resolved = resolveType(type, receiverContext, receiverContext === file ? call.line : undefined, qualifier);
+    // A type name resolves where it was written: a field typed by
+    // `self.x = Local()` names the class visible at that write (fix #381).
+    const typeLine = Number.isInteger(options.receiverTypeLine) ? options.receiverTypeLine : call.line;
+    let resolved = resolveType(type, receiverContext, receiverContext === file ? typeLine : undefined, qualifier);
     if (resolved && receiverContext !== originFile && resolved.declaration.file !== originFile) resolved = null;
     if (!resolved && language === 'rust') {
-        const enclosing = index.findEnclosingFunction(file, call.line, true);
+        const enclosing = index.findEnclosingFunction(file, call.line, true, call);
         const bounds = enclosing?.genericBounds?.[type];
         const boundTypes = (bounds || []).map(bound => resolveType(bound, file, call.line))
             .filter(bound => bound?.declaration.type === 'trait' &&
@@ -224,8 +309,11 @@ function confirmationFacts(index, file, call, targets, options = {}) {
         const key = identityKey(identity);
         if (visited.has(key) || visited.size >= 16) return null;
         visited.add(key);
-        const members = (index.symbols.get(call.name) || []).filter(d => {
-            if (NON_CALLABLE_TYPES.has(d.type) || ownerName(d) !== owner.name) return false;
+        const ownerDefinition = owner.file && TYPE_KINDS.has(owner.type) ? owner : null;
+        const members = callableMembersOwnedBy(index, call.name, owner.name).filter(d => {
+            // A member of a same-name class declared in another scope of
+            // the file is not this owner's member (fix #389).
+            if (ownerDefinition && distinctOwnerDefinitions(index, d, ownerDefinition, true)) return false;
             if (language === 'csharp' && d.explicitInterface &&
                 (!facts.receiverCastThis || d.explicitInterface !== facts.receiverCastThis.interfaceType)) return false;
             if ((d.namespace || null) !== (owner.namespace || null)) return false;
@@ -248,6 +336,27 @@ function confirmationFacts(index, file, call, targets, options = {}) {
             facts.lookupUnsupported = 'external-parent-member';
             return null;
         }
+        // A C++ using-declaration in the class body (`using Base::name;`,
+        // fix #401) brings the base's members of the name into this lookup
+        // set: the arguments choose among both. The witness only states a
+        // member of this class, so a choice it cannot express (a base
+        // member, or no choice) leaves the lookup unproven.
+        if (language === 'cpp' && members.length > 0 && parents.length > 0) {
+            const usingBases = require('./callers')._cppMemberUsingBases(index, owner.name, call.name, owner.file);
+            const brought = usingBases && usingBases.size > 0 ? parents.filter(parent => usingBases.has('*') ||
+                usingBases.has(String(parent.name).replace(/<.*$/s, '').split('::').pop())) : [];
+            if (brought.length > 0) {
+                const baseMembers = brought.flatMap(parent =>
+                    callableMembersOwnedBy(index, call.name, parent.name).filter(d => d.file === parent.file));
+                let choice;
+                try {
+                    choice = options.selectOverload ? options.selectOverload(index, call, [...members, ...baseMembers], language) : null;
+                } catch {
+                    choice = null;
+                }
+                if (!choice?.match || members.length !== 1 || choice.match !== members[0]) return null;
+            }
+        }
         const step = { owner: identity, members: members.map(declarationIdentity), parents: parents.map(declarationIdentity),
             ...(derefTarget && { derefTarget }) };
         const getter = facts.valueReference && propertyReadMember(step.members);
@@ -269,12 +378,47 @@ function confirmationFacts(index, file, call, targets, options = {}) {
             receiver: declarationIdentity(resolved.declaration),
             steps: [...steps, step], selected: declarationIdentity(members[0]),
         };
+        // Configuration alternatives of one member (fix #385: `#ifdef _WIN32
+        // bool f() ... #else bool f() ... #endif` in one class body) are the
+        // member in each build configuration: the lookup selects the item.
+        if (members.length > 1) {
+            const { _isConfigurationAlternative } = require('./callers');
+            if (members.slice(1).every(member => _isConfigurationAlternative(index, members[0], member))) {
+                return {
+                    receiver: declarationIdentity(resolved.declaration),
+                    steps: [...steps, step], selected: declarationIdentity(members[0]),
+                    configurationItem: members.map(declarationIdentity),
+                };
+            }
+        }
         if (members.length > 1 && options.selectOverload) {
-            const overload = captureOverload(index, call, members, language, options.selectOverload);
+            // The choice is made on the index itself first (its memos stay
+            // on); only a selected member needs the replayable witness.
+            let choice;
+            try {
+                choice = options.selectOverload(index, call, members, language);
+            } catch {
+                choice = null;
+            }
+            const overload = choice?.match
+                ? captureOverload(index, call, members, language, options.selectOverload) : null;
             if (overload?.selected) return {
                 receiver: declarationIdentity(resolved.declaration),
                 steps: [...steps, { ...step, overload }], selected: overload.selected,
             };
+            // Every member the lookup found is known but the arguments cannot
+            // choose one (fix #396). Name lookup stops at the declaring class,
+            // so the callee is one of its members of that name: the witness
+            // (`memberSet`) proves that a target outside them is not the
+            // callee without replaying the overload choice. The hops before
+            // the declaring class declare no member of the name.
+            if (!choice?.match && choice?.ambiguous === true && steps.every(prior => prior.members.length === 0)) {
+                return {
+                    receiver: declarationIdentity(resolved.declaration),
+                    steps: [...steps, step],
+                    selected: declarationIdentity(members[0]), memberSet: true,
+                };
+            }
         }
         if (members.length || parents.length !== 1) return null;
         return walk(parents[0], [...steps, step]);
@@ -284,4 +428,4 @@ function confirmationFacts(index, file, call, targets, options = {}) {
     return facts;
 }
 
-module.exports = { confirmationFacts, namedDeclaration, occurrenceIdentity };
+module.exports = { confirmationFacts, namedDeclaration, occurrenceIdentity, definitionsInFile, definitionAt };

package/core/provenance-overload.js

@@ -30,8 +30,21 @@ function factIndex(reads, live) {
         if (!Object.hasOwn(reads, key)) throw new Error(`Missing overload fact: ${key}`);
         return decode(reads[key]);
     };
+    // A map-like read answers with one object per key, as the live index's
+    // Map.get does (fix #388: decoding the same file entry again for every
+    // read dominated warm `find` on Java projects).
+    const mapReads = new Map();
+    const readMapValue = (key, compute) => {
+        if (mapReads.has(key)) return mapReads.get(key);
+        const value = read(key, compute);
+        mapReads.set(key, value);
+        return value;
+    };
     return new Proxy({}, {
         get(_, property) {
+            // Callers skip their per-operation memos on this facade: every
+            // read must be recorded for the replay (fix #396).
+            if (property === 'isProvenanceFactIndex') return true;
             if (local.has(property)) return local.get(property);
             if (String(property).includes('Cache')) {
                 const cache = new Map(); local.set(property, cache); return cache;
@@ -39,7 +52,7 @@ function factIndex(reads, live) {
             if (['symbols', 'files', 'importGraph', 'extendsGraph', 'extendedByGraph'].includes(property)) {
                 return {
                     get(key) {
-                        return read(`${property}.get:${JSON.stringify(key)}`, () => {
+                        return readMapValue(`${property}.get:${JSON.stringify(key)}`, () => {
                             const value = live[property]?.get(key);
                             if (property !== 'files' || !value) return value;
                             return { language: value.language, relativePath: value.relativePath,
@@ -62,11 +75,25 @@ function factIndex(reads, live) {
     });
 }
 
+// Index definitions are immutable records: one encoding each (fix #396:
+// every excluded receiver site of a many-overload name encoded the whole
+// candidate set again). The encoding is read-only witness data.
+const ENCODED_DEFINITIONS = new WeakMap();
+function encodeDefinition(definition) {
+    if (!definition || typeof definition !== 'object') return encode(definition);
+    let encoded = ENCODED_DEFINITIONS.get(definition);
+    if (!encoded) {
+        encoded = encode(definition);
+        ENCODED_DEFINITIONS.set(definition, encoded);
+    }
+    return encoded;
+}
+
 function captureOverload(index, call, candidates, language, select) {
     const reads = {};
     try {
         const result = select(factIndex(reads, index), call, candidates, language);
-        return { call: encode(call), candidates: encode(candidates), language, reads,
+        return { call: encode(call), candidates: candidates.map(encodeDefinition), language, reads,
             selected: declarationIdentity(result.match),
             outcome: result.match ? 'selected' : result.ambiguous ? 'ambiguous' : 'no-fit' };
     } catch { return null; }
@@ -115,4 +142,4 @@ function overloadMemberGroup(steps) {
     return group;
 }
 
-module.exports = { captureOverload, validateOverload, overloadMemberGroup };
+module.exports = { captureOverload, validateOverload, overloadMemberGroup, factIndex };

package/core/provenance.js

@@ -1,5 +1,10 @@
 'use strict';
 
+// A source offset. Facts produced inside a Rust macro expansion (fix #374)
+// carry fractional offsets within the invocation: positions without a
+// source token of their own, still ordered and paired.
+const isOffset = value => Number.isFinite(value) && value >= 0;
+
 const { codeUnitCompare } = require('./shared');
 
 const TYPE_SOURCE_RULES = Object.freeze({
@@ -29,21 +34,35 @@ function declarationIdentity(definition) {
     };
 }
 
+function validIdentity(identity) {
+    return !!identity && !!identity.file && Number.isInteger(identity.startLine) &&
+        !!identity.name && !!identity.kind;
+}
+
+/**
+ * A declaration identity's key, or null when the identity is incomplete.
+ * Fields are joined with NUL (no path, name or kind contains one); an
+ * absent optional field is the empty string.
+ */
 function identityKey(identity) {
-    if (!identity || !identity.file || !Number.isInteger(identity.startLine) ||
-        !identity.name || !identity.kind) return null;
-    return JSON.stringify([
-        identity.file, identity.startLine, identity.endLine ?? null,
-        identity.name, identity.kind, identity.className || null,
-        identity.namespace || null, identity.enclosingType || null,
-        identity.lexicalScopeStartLine || null, identity.lexicalScopeEndLine || null,
-        identity.bindingId || null,
-    ]);
+    if (!validIdentity(identity)) return null;
+    return `${identity.file}\0${identity.startLine}\0${identity.endLine ?? ''}\0${identity.name}\0` +
+        `${identity.kind}\0${identity.className || ''}\0${identity.namespace || ''}\0` +
+        `${identity.enclosingType || ''}\0${identity.lexicalScopeStartLine || ''}\0` +
+        `${identity.lexicalScopeEndLine || ''}\0${identity.bindingId || ''}`;
 }
 
+/** Do two complete identities name one declaration (field by field)? */
 function sameDeclaration(left, right) {
-    const key = identityKey(left);
-    return key !== null && key === identityKey(right);
+    if (!validIdentity(left) || !validIdentity(right)) return false;
+    return left.file === right.file && left.startLine === right.startLine &&
+        (left.endLine ?? null) === (right.endLine ?? null) && left.name === right.name &&
+        left.kind === right.kind && (left.className || null) === (right.className || null) &&
+        (left.namespace || null) === (right.namespace || null) &&
+        (left.enclosingType || null) === (right.enclosingType || null) &&
+        (left.lexicalScopeStartLine || null) === (right.lexicalScopeStartLine || null) &&
+        (left.lexicalScopeEndLine || null) === (right.lexicalScopeEndLine || null) &&
+        (left.bindingId || null) === (right.bindingId || null);
 }
 
 function propertyReadMember(members) {
@@ -65,13 +84,13 @@ function validateConfirmation(provenance, target, invalidCall = false) {
     const verdictFor = declaration => targets.some(t => sameDeclaration(t, declaration))
         ? { verdict: 'establishes-target' }
         : { verdict: 'establishes-other', declaration };
-    if (!targets.length || targets.some(t => !identityKey(t))) return incomplete('missing-target-identity');
+    if (!targets.length || targets.some(t => !validIdentity(t))) return incomplete('missing-target-identity');
     if (facts.receiverOrigin?.externalFactory) {
         const factory = facts.receiverOrigin.externalFactory;
         const empty = value => Array.isArray(value) && !value.length;
-        const span = origin => Number.isInteger(origin?.start) && Number.isInteger(origin?.end) && origin.end > origin.start;
+        const span = origin => isOffset(origin?.start) && isOffset(origin?.end) && origin.end > origin.start;
         if (facts.language !== 'python' || facts.receiverTypeSource !== 'flow' ||
-            !identityKey(factory.owner) || !identityKey(factory.enclosing) ||
+            !validIdentity(factory.owner) || !validIdentity(factory.enclosing) ||
             factory.owner.file !== facts.site?.file || factory.enclosing.file !== factory.owner.file ||
             factory.enclosing.className !== factory.owner.name || !factory.field ||
             facts.site.line < factory.enclosing.startLine || facts.site.line > factory.enclosing.endLine ||
@@ -108,7 +127,7 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             !['annotation', 'constructor', 'flow'].includes(binding.origin?.source) ||
             (binding.referenceAnnotation && (binding.origin.source !== 'annotation' ||
                 !binding.referenceAnnotation.trim().startsWith('&'))) ||
-            !Number.isInteger(binding.assignment?.start) || !Number.isInteger(binding.assignment?.end)) {
+            !isOffset(binding.assignment?.start) || !isOffset(binding.assignment?.end)) {
             return incomplete('invalid-copied-receiver-binding');
         }
     }
@@ -140,9 +159,10 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         const producer = facts.receiverOrigin.moduleProducer;
         const call = producer.call, declaration = producer.declaration;
         if (facts.language !== 'rust' || !call?.receiver || !call.name || !call.file ||
-            !Number.isInteger(call.start) || !Number.isInteger(call.end) ||
-            !identityKey(declaration) || declaration.className || !declaration.returnType ||
-            declaration.name !== call.name || declaration.file !== producer.module?.file) {
+            !isOffset(call.start) || !isOffset(call.end) ||
+            !validIdentity(declaration) || declaration.className || !declaration.returnType ||
+            declaration.name !== call.name ||
+            declaration.file !== (producer.module?.reexportedFrom || producer.module?.file)) {
             return incomplete('invalid-module-producer-declaration');
         }
         const segments = call.receiver.split('::');
@@ -153,8 +173,12 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         const specifier = binding ? [binding.module, ...segments.slice(1)].join('::') : call.receiver;
         const fileParts = producer.module.file.split('/');
         const base = fileParts.pop().replace(/\.rs$/, '');
+        // A crate-name specifier (`cursive::default()`) owns the crate root
+        // file, whose basename is lib/main (fix #369).
+        const crateRoot = producer.module.crateRoot === true && !specifier.includes('::') &&
+            (base === 'lib' || base === 'main');
         if (specifier !== producer.module.specifier ||
-            specifier.split('::').at(-1) !== (base === 'mod' ? fileParts.pop() : base)) {
+            (!crateRoot && specifier.split('::').at(-1) !== (base === 'mod' ? fileParts.pop() : base))) {
             return inconsistent('module-producer-path-mismatch');
         }
     }
@@ -198,8 +222,8 @@ function validateConfirmation(provenance, target, invalidCall = false) {
                 pattern.contract?.kind === (pattern.variant === 'Some' ? 'Option' : 'Result') &&
                 Array.isArray(pattern.shadowDeclarations) && !pattern.shadowDeclarations.length &&
                 Array.isArray(pattern.shadowBindings) && !pattern.shadowBindings.length &&
-                (pattern.source?.variable || (Number.isInteger(pattern.source?.start) &&
-                    Number.isInteger(pattern.source?.end) && pattern.source.end > pattern.source.start))
+                (pattern.source?.variable || (isOffset(pattern.source?.start) &&
+                    isOffset(pattern.source?.end) && pattern.source.end > pattern.source.start))
             : ['unwrap', 'expect'].includes(unwrap.method);
         if (facts.language !== 'rust' || !validProjection ||
             !require('./rust-result-flow').validateRustWrapperContract(unwrap.contract)) {
@@ -222,7 +246,7 @@ function validateConfirmation(provenance, target, invalidCall = false) {
     }
     if (facts.lookup) {
         const { receiver, steps, selected } = facts.lookup;
-        if (!identityKey(receiver) || !identityKey(selected) || !Array.isArray(steps) || !steps.length) {
+        if (!validIdentity(receiver) || !validIdentity(selected) || !Array.isArray(steps) || !steps.length) {
             return incomplete('missing-receiver-lookup');
         }
         if (!sameDeclaration(receiver, steps[0].owner)) return inconsistent('lookup-origin-mismatch');
@@ -240,19 +264,19 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         let resolvedAlias = typeDeclaration;
         for (const alias of aliases) {
             if (!sameDeclaration(alias.declaration, resolvedAlias) ||
-                !alias.aliasOf || !alias.name || !identityKey(alias.target)) return inconsistent('receiver-alias-chain-mismatch');
+                !alias.aliasOf || !alias.name || !validIdentity(alias.target)) return inconsistent('receiver-alias-chain-mismatch');
             const head = String(alias.aliasOf).replace(/^[*&\s]+/, '').split(/[<[]/, 1)[0].trim().split(/::|\./).pop();
             if (head !== alias.name.split(/::|\./).pop() || head !== alias.target.name) return inconsistent('receiver-alias-target-mismatch');
             resolvedAlias = alias.target;
         }
         if (!sameDeclaration(resolvedAlias, receiver)) return inconsistent('receiver-alias-end-mismatch');
         const bound = facts.receiverGenericBound;
-        if (bound && (!identityKey(bound.declaration) || bound.parameter !== facts.receiverType ||
+        if (bound && (!validIdentity(bound.declaration) || bound.parameter !== facts.receiverType ||
             !bound.bounds?.includes(typeDeclaration.name) || !sameDeclaration(bound.selected, typeDeclaration))) {
             return inconsistent('receiver-generic-bound-mismatch');
         }
         const castThis = facts.receiverCastThis;
-        if (castThis && (!identityKey(castThis.enclosing) ||
+        if (castThis && (!validIdentity(castThis.enclosing) ||
             castThis.enclosing.className !== receiver.name || castThis.enclosing.file !== receiver.file ||
             castThis.interfaceType !== facts.receiverType)) return inconsistent('receiver-this-cast-mismatch');
         const overload = facts.lookup.overload;
@@ -262,9 +286,18 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             return inconsistent('selected-member-outside-overload-group');
         }
         const ambiguousOverload = overload?.outcome === 'ambiguous';
+        const configurationItem = !overload && Array.isArray(facts.lookup.configurationItem)
+            ? facts.lookup.configurationItem : null;
+        if (configurationItem && configurationItem.some(item => !validIdentity(item))) {
+            return incomplete('missing-configuration-item');
+        }
+        // Every same-name member of the declaring class, the arguments
+        // choosing none (fix #396): the callee is one of them.
+        const memberSet = !overload && !configurationItem && facts.lookup.memberSet === true;
+        let memberSetMembers = null;
         for (let i = 0; i < steps.length; i++) {
             const step = steps[i];
-            if (!identityKey(step.owner) || !Array.isArray(step.members) || !Array.isArray(step.parents)) {
+            if (!validIdentity(step.owner) || !Array.isArray(step.members) || !Array.isArray(step.parents)) {
                 return incomplete('missing-member-lookup-facts');
             }
             const named = step.members.filter(member => member.name === selected.name);
@@ -279,6 +312,19 @@ function validateConfirmation(provenance, target, invalidCall = false) {
                 if (!step.parents.some(parent => sameDeclaration(parent, steps[i + 1].owner))) {
                     return inconsistent('unproven-inheritance-hop');
                 }
+            } else if (configurationItem) {
+                // One member in several build configurations: the witness
+                // names exactly the step's same-name members.
+                if (named.length !== configurationItem.length ||
+                    !named.every(member => configurationItem.some(item => sameDeclaration(item, member))) ||
+                    !configurationItem.some(item => sameDeclaration(item, selected))) {
+                    return inconsistent('configuration-item-mismatch');
+                }
+            } else if (memberSet) {
+                if (named.length < 2 || !named.some(member => sameDeclaration(member, selected))) {
+                    return inconsistent('member-set-mismatch');
+                }
+                memberSetMembers = named;
             } else if (!overload && (named.length !== 1 || !sameDeclaration(named[0], selected))) {
                 const propertyRead = facts.valueReference && step.propertyRead &&
                     sameDeclaration(propertyReadMember(named), selected);
@@ -300,6 +346,12 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         if (facts.receiverOrigin.source !== facts.receiverTypeSource) {
             return inconsistent('receiver-source-mismatch');
         }
+        if (memberSetMembers) {
+            if (targets.some(target => memberSetMembers.some(member => sameDeclaration(target, member)))) {
+                return incomplete('ambiguous-or-missing-member');
+            }
+            return { verdict: 'establishes-other', declarations: memberSetMembers };
+        }
         if (ambiguousOverload) {
             // Every overload is known, but the argument shape cannot choose
             // one. This proves no particular target. It can still establish
@@ -310,10 +362,15 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             }
             return { verdict: 'establishes-other', declarations };
         }
+        if (configurationItem) {
+            return targets.some(target => configurationItem.some(item => sameDeclaration(target, item)))
+                ? { verdict: 'establishes-target' }
+                : { verdict: 'establishes-other', declarations: configurationItem };
+        }
         return verdictFor(selected);
     }
     if (facts.binding) {
-        if (!identityKey(facts.binding.declaration) || !facts.binding.referenceId ||
+        if (!validIdentity(facts.binding.declaration) || !facts.binding.referenceId ||
             facts.binding.referenceId !== facts.binding.declaration.bindingId) {
             return incomplete('missing-binding-witness');
         }
@@ -350,7 +407,7 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             }
         }
         const last = chain.at(-1);
-        if (!identityKey(last.declaration) || last.declaration.file !== last.toFile ||
+        if (!validIdentity(last.declaration) || last.declaration.file !== last.toFile ||
             last.declaration.name !== last.importedName) return incomplete('missing-import-declaration');
         return verdictFor(last.declaration);
     }
@@ -385,9 +442,26 @@ function createProvenance(evidence, resolution) {
     if (evidence.moduleOwnedPath) rules.push('module-owned');
     if (evidence.hasBindingId) rules.push('binding');
     if (evidence.hasSingleOwnerEvidence) rules.push('single-owner');
-    if (evidence.hasImportEvidence) rules.push(facts.importChain ? 'import-chain' : 'import-supported');
+    if (evidence.hasImportEvidence) {
+        // A C/C++ include closure that needs a basename-resolved include
+        // edge (no compile database or include path proves it) is the
+        // weaker include evidence (fix #361).
+        rules.push(evidence.includeBasename ? 'include-basename'
+            : facts.importChain ? 'import-chain' : 'import-supported');
+    }
     if (evidence.hasReceiverEvidence) rules.push('receiver-binding');
     if (evidence.hasSamePackageEvidence) rules.push('same-package');
+    // A call target produced by expanding a project macro invocation
+    // (fix #362) leads the rule list: the name exists only after token
+    // substitution, whatever scope evidence then bound it.
+    if (evidence.macroExpansion) {
+        rules.unshift('macro-expansion');
+        facts.macroExpansion = {
+            macro: evidence.macroExpansion.macro,
+            definition: evidence.macroExpansion.definition,
+            origin: evidence.macroExpansion.origin,
+        };
+    }
     if (!rules.length) rules.push(evidence.reason || resolution || 'unknown');
     const provenance = { rule: rules[0], rules: [...new Set(rules)], facts };
     if (facts.targets?.length) {
@@ -418,6 +492,6 @@ function summarizeProvenance(sites) {
 }
 
 module.exports = {
-    TYPE_SOURCE_RULES, declarationIdentity, identityKey, sameDeclaration, propertyReadMember,
+    TYPE_SOURCE_RULES, declarationIdentity, identityKey, validIdentity, sameDeclaration, propertyReadMember,
     validateConfirmation, validateCallMismatch, createProvenance, summarizeProvenance,
 };