ucn 5.5.1 → 5.5.3

package/core/check.js

@@ -12,6 +12,7 @@
 'use strict';
 
 const { diffImpact, composeAccount, callNotResolvedEntries } = require('./analysis');
+const { isValueDefinition } = require('./shared');
 
 function summarizeAccount(account) {
     if (!account) {
@@ -123,13 +124,22 @@ function check(index, options = {}) {
     for (const fn of changed) {
         const filePath = fn.relativePath || fn.file || '';
         if (fn._nonCallable) {
-            const dependency = fn.impact?.typeReferences || fn.impact?.propertyAccesses;
+            const dependency = fn.impact?.typeReferences || fn.impact?.propertyAccesses || fn.impact?.valueAccesses;
+            // A value declaration (field, constant, module variable) is read
+            // and written through its value-access sites (fix #420): its
+            // change is reviewed there, as a function body change is through
+            // its callers. A type's shape and inheritance are not checked.
+            const valueDeclaration = isValueDefinition(fn);
             items.push({
                 name: fn.name, file: filePath, line: fn.startLine, kind: fn._kind,
                 symbolType: fn.type, requiresToolchainValidation: true,
+                ...(valueDeclaration && { valueDeclaration: true }),
                 callerCount: fn.impact?.totalCallSites || 0,
                 unverifiedCallerCount: fn.impact?.unverifiedSites?.length || 0,
-                dependencyCount: dependency?.confirmedCount || 0,
+                // Non-call sites: a value band also lists its call tokens.
+                dependencyCount: valueDeclaration && Number.isInteger(fn.impact?.totalDependencySites)
+                    ? Math.max(0, fn.impact.totalDependencySites - (fn.impact.totalCallSites || 0))
+                    : dependency?.confirmedCount || 0,
                 unverifiedDependencyCount: (dependency?.unverifiedCount || 0) + (fn.remainingReferences?.length || 0),
                 signatureMismatches: 0,
                 account: summarizeAccount(fn.impact?.account),
@@ -237,7 +247,13 @@ function check(index, options = {}) {
     // Action items
     const actions = [];
     for (const it of items) {
-        if (it.requiresToolchainValidation) {
+        if (it.requiresToolchainValidation && it.valueDeclaration && it.kind !== 'deleted') {
+            actions.push({
+                severity: 'warn',
+                kind: 'value_change',
+                message: `${it.name}: ${it.kind} ${it.symbolType}; review its ${it.dependencyCount + it.callerCount} value access site(s) and run the compiler/type checker and tests`,
+            });
+        } else if (it.requiresToolchainValidation) {
             actions.push({
                 severity: it.kind === 'added' ? 'warn' : 'error',
                 kind: 'declaration_change',
@@ -308,10 +324,11 @@ function check(index, options = {}) {
     const signatureMismatches = items.reduce((sum, it) => sum + (it.signatureMismatches || 0), 0);
     const filteredEdges = items.reduce((sum, it) => sum + (it.account ? it.account.filtered || 0 : 0), 0);
     const usageReviewSymbols = items.filter(it => it.account && it.account.requiresUsageReview).length;
-    const unvalidatedDeclarations = items.filter(it => it.requiresToolchainValidation && it.kind !== 'added').length;
+    const unvalidatedDeclarations = items.filter(it => it.requiresToolchainValidation && it.kind !== 'added' &&
+        !(it.valueDeclaration && it.kind === 'modified')).length;
     const reviewRequired = incompleteAccounts > 0 || unverifiedCallSites > 0 ||
         signatureMismatches > 0 || filteredEdges > 0 || usageReviewSymbols > 0 ||
-        actions.some(a => a.kind === 'orphan_new' || a.kind === 'declaration_change') ||
+        actions.some(a => a.kind === 'orphan_new' || a.kind === 'declaration_change' || a.kind === 'value_change') ||
         !!(limit && allChanged.length > limit);
 
     return {

package/core/class-identity.js

@@ -33,6 +33,7 @@ const path = require('path');
 const { langTraits } = require('../languages');
 const { splitParentList } = require('./graph-build');
 const { genericArityOf } = require('../languages/utils');
+const { symbolsSpanning } = require('./shared');
 
 const OWNER_CLASS_KINDS = new Set([
     'class', 'struct', 'interface', 'trait', 'enum', 'record', 'union',
@@ -40,6 +41,32 @@ const OWNER_CLASS_KINDS = new Set([
 const TRANSITIVE_IMPORT_DEPTH = 4;
 const TRANSITIVE_IMPORT_FILE_CAP = 2000;
 
+/** Complete a plain C-family declaration in the consuming translation unit.
+ * A declaration's name alone never selects a definition in another program. */
+function completeForwardDeclaration(index, declaration, useFile) {
+    if (!declaration?.forwardDeclaration || !useFile ||
+        !langTraits(index.files.get(declaration.file)?.language)?.textualIncludes ||
+        declaration.anonymousNamespace || declaration.ppBranch ||
+        declaration.generics?.length || declaration.specialization ||
+        declaration.lexicalScopeStartLine || declaration.typedefName) return declaration;
+    const { includeClosure, effectiveNamespace } = require('./cpp-scope');
+    const visible = includeClosure(index, useFile);
+    if (declaration.file !== useFile && !visible.has(declaration.file)) return declaration;
+    const namespace = effectiveNamespace(index, declaration);
+    const recordKind = kind => ['class', 'struct'].includes(kind) ? 'record' : kind;
+    const providers = (index.symbols.get(declaration.name) || []).filter(candidate =>
+        OWNER_CLASS_KINDS.has(candidate.type) && !candidate.forwardDeclaration &&
+        !candidate.aliasOf && !candidate.typedefName && !candidate.anonymousNamespace &&
+        !candidate.ppBranch && !candidate.generics?.length && !candidate.specialization &&
+        !candidate.lexicalScopeStartLine &&
+        langTraits(index.files.get(candidate.file)?.language)?.textualIncludes &&
+        recordKind(candidate.type) === recordKind(declaration.type) &&
+        (candidate.enclosingType || '') === (declaration.enclosingType || '') &&
+        effectiveNamespace(index, candidate) === namespace &&
+        (candidate.file === useFile || visible.has(candidate.file)));
+    return providers.length === 1 ? providers[0] : declaration;
+}
+
 function _state(index) {
     let state = index._classIdentity;
     if (!state) {
@@ -47,12 +74,15 @@ function _state(index) {
             named: new Map(),
             classKeys: new WeakMap(),
             owners: new WeakMap(),
+            lexicalOwners: new WeakMap(),
+            lexicalTypes: new WeakMap(),
             resolved: new Map(),
             parents: new Map(),
             modules: new Map(),
             // fix #365: target-independent derivations repeated for every
             // same-name definition a caller query pins (stats --hot / repo).
             declaring: new WeakMap(), // definitions array -> Map<refKey|mode, result>
+            linearizations: new Map(),
             descendants: new Map(),   // class key -> descendant key Set (default cap)
             // fix #389: certain owner definitions, same-file namesake counts,
             // names with function-local class definitions.
@@ -62,6 +92,8 @@ function _state(index) {
             // fix #390: class name -> Set of files declaring it without a
             // possible base elsewhere (see fileDeclaresClass).
             declaringFiles: new Map(),
+            // fix #427: forward declaration -> the class it declares.
+            forwardProviders: new WeakMap(),
         };
         index._classIdentity = state;
     }
@@ -85,11 +117,12 @@ function ownerNameOf(member) {
  * file (another def whose range strictly contains it), 0 at module level.
  */
 function _enclosingScopeStart(index, def) {
-    const fileEntry = index.files.get(def.file);
-    const symbols = fileEntry?.symbols;
+    const symbols = require('./provenance-overload').containingDeclarations(index, def);
     if (!Array.isArray(symbols)) return 0;
     let best = null;
-    for (const s of symbols) {
+    // Only declarations holding the definition's first line can enclose it.
+    const around = def.endLine >= def.startLine ? symbolsSpanning(symbols, def.startLine) : symbols;
+    for (const s of around) {
         if (s === def || s.startLine == null || s.endLine == null) continue;
         if (s.startLine > def.startLine) continue;
         if (s.endLine < def.endLine) continue;
@@ -99,10 +132,57 @@ function _enclosingScopeStart(index, def) {
     return best ? best.startLine : 0;
 }
 
+/**
+ * The class a C/C++ forward declaration (`class State;`) declares, when the
+ * project defines exactly one class identity of its qualified name and kind
+ * (fix #427): every declaration of `Y::State` in a program names one class,
+ * and a member access through it compiles only where it is complete.
+ * Several definitions (separate programs, a vendored copy) leave it apart.
+ */
+function forwardDeclarationProvider(index, declaration) {
+    if (!declaration?.forwardDeclaration || declaration.anonymousNamespace ||
+        declaration.specialization || declaration.lexicalScopeStartLine || declaration.typedefName ||
+        !langTraits(index.files.get(declaration.file)?.language)?.textualIncludes) return null;
+    const state = _state(index);
+    if (state.forwardProviders.has(declaration)) return state.forwardProviders.get(declaration);
+    const { effectiveNamespace } = require('./cpp-scope');
+    const namespace = effectiveNamespace(index, declaration);
+    const recordKind = kind => ['class', 'struct'].includes(kind) ? 'record' : kind;
+    // Template parameter count (`generics` is the written `<T, U>` list or an array).
+    const arity = definition => {
+        const generics = definition.generics;
+        if (!generics) return 0;
+        if (Array.isArray(generics)) return generics.length;
+        const inner = String(generics).trim().replace(/^<|>$/g, '').trim();
+        return inner ? inner.split(',').length : 0;
+    };
+    const providers = (index.symbols.get(declaration.name) || []).filter(candidate =>
+        candidate !== declaration && OWNER_CLASS_KINDS.has(candidate.type) && !candidate.forwardDeclaration &&
+        !candidate.aliasOf && !candidate.typedefName && !candidate.anonymousNamespace &&
+        !candidate.specialization && !candidate.lexicalScopeStartLine &&
+        langTraits(index.files.get(candidate.file)?.language)?.textualIncludes &&
+        recordKind(candidate.type) === recordKind(declaration.type) &&
+        (candidate.enclosingType || '') === (declaration.enclosingType || '') &&
+        arity(candidate) === arity(declaration) &&
+        effectiveNamespace(index, candidate) === namespace);
+    // `#if` alternatives of one definition share its key.
+    const provider = providers.length > 0 &&
+        new Set(providers.map(candidate => classKeyOf(index, candidate))).size === 1 ? providers[0] : null;
+    state.forwardProviders.set(declaration, provider);
+    return provider;
+}
+
 /** Identity key of one class definition. */
 function classKeyOf(index, def) {
     const state = _state(index);
     let key = state.classKeys.get(def);
+    if (key === undefined && def?.forwardDeclaration) {
+        const provider = forwardDeclarationProvider(index, def);
+        if (provider) {
+            key = classKeyOf(index, provider);
+            state.classKeys.set(def, key);
+        }
+    }
     if (key === undefined) {
         // A `partial` type (C#) is ONE class declared across files: its
         // identity is the namespace + enclosing type + name, never the file.
@@ -110,9 +190,13 @@ function classKeyOf(index, def) {
         // the same type-parameter count merge (`partial class P<T>` never
         // joins `partial class P`).
         const arity = def.typeArity ? `|${def.typeArity}` : '';
+        const lexicalScope = _enclosingScopeStart(index, def);
+        // A nested declaration can share every source line with its
+        // enclosing type. The recorded owner still distinguishes its scope.
+        const scope = def.enclosingType ? `${lexicalScope}:${def.enclosingType}` : lexicalScope;
         key = Array.isArray(def.modifiers) && def.modifiers.includes('partial')
             ? `partial|${def.namespace || ''}|${def.enclosingType || ''}|${def.name}${arity}`
-            : `${def.file}|${def.namespace || ''}|${_enclosingScopeStart(index, def)}|${def.name}${arity}`;
+            : `${def.file}|${def.namespace || ''}|${scope}|${def.name}${arity}`;
         state.classKeys.set(def, key);
     }
     return key;
@@ -132,6 +216,12 @@ function classDefsNamed(index, name) {
     let entries = defs.length <= 1
         ? defs.map(def => ({ def, key: `name:${name}` }))
         : defs.map(def => ({ def, key: classKeyOf(index, def) }));
+    // A forward declaration of a defined class shares its key (fix #427);
+    // the definition represents the class, never the declaration.
+    if (entries.length > 1 && entries.some(entry => entry.def.forwardDeclaration)) {
+        entries = [...entries.filter(entry => !entry.def.forwardDeclaration),
+            ...entries.filter(entry => entry.def.forwardDeclaration)];
+    }
     const unique = new Set(entries.map(e => e.key)).size <= 1;
     // One identity (a single def, or the parts of one partial/merged type):
     // every consumer uses the name key, so comparisons stay consistent.
@@ -292,11 +382,22 @@ function _resolveAmong(index, entries, contextFile, namespace) {
     const traits = langTraits(language);
     // 2. Directory package scope (Go): every file of the package sees it.
     if (traits?.packageScope === 'directory') {
-        const dir = path.dirname(contextFile);
-        const samePkg = entries.filter(e => path.dirname(e.def.file) === dir);
+        // The file's own package (fix #425): `package x_test` is another
+        // package of the directory, which sees x's names through a dot import.
+        const { goBareNameReaches } = require('./go-packages');
+        const samePkg = entries.filter(e => goBareNameReaches(index, contextFile, e.def));
         if (samePkg.length > 0) return _single(samePkg);
     }
-    // 3. Direct imports.
+    // 3. A C# namespace's own members precede the types its using
+    //    directives import (fix #430): `Post` inside namespace
+    //    `Dapper.Tests.Performance` is that namespace's Post whatever
+    //    `using Dapper.Tests.Performance.Dashing;` brings.
+    if (traits?.typeNameScoping === 'namespace-usings') {
+        const own = _contextNamespace(index, contextFile, namespace);
+        const declared = own ? entries.filter(e => e.def.namespace === own) : [];
+        if (declared.length > 0) return _single(declared);
+    }
+    // 4. Direct imports.
     const imports = index.importGraph.get(contextFile);
     if (imports && imports.size > 0) {
         const imported = entries.filter(e => imports.has(e.def.file));
@@ -317,7 +418,7 @@ function _resolveAmong(index, entries, contextFile, namespace) {
         }
         if (imported.length > 0) return _single(imported);
     }
-    // 4. Same or enclosing namespace/package (Java packages, C#/C++
+    // 5. Same or enclosing namespace/package (Java packages, C#/C++
     //    namespaces), nearest first.
     const ns = _contextNamespace(index, contextFile, namespace);
     if (ns) {
@@ -329,7 +430,7 @@ function _resolveAmong(index, entries, contextFile, namespace) {
             return _single(visible.filter(e => e.def.namespace.length === longest));
         }
     }
-    // 5. Re-exports: the nearest transitive import reach, when unique.
+    // 6. Re-exports: the nearest transitive import reach, when unique.
     return _transitiveImportMatch(index, contextFile, entries);
 }
 
@@ -374,6 +475,41 @@ function ownerRefOf(index, member) {
     return ref;
 }
 
+/**
+ * A nested callable's lexical type for simple-name lookup (fix #412).
+ * This is not member ownership: a local function stays a function, while
+ * names in its body can reach the surrounding type's members. A nested
+ * type's enclosing type is found by the same containment rule.
+ */
+function lexicalClassRefOf(index, definition) {
+    if (ownerNameOf(definition)) return ownerRefOf(index, definition);
+    if (!definition?.file || (!definition.isNested && !definition.enclosingType)) return null;
+    const entry = index.files.get(definition.file);
+    if (!entry || !langTraits(entry.language)?.bareCallReachesMethods) return null;
+    const state = _state(index);
+    if (state.lexicalOwners.has(definition)) return state.lexicalOwners.get(definition);
+    let types = state.lexicalTypes.get(entry);
+    if (!types) {
+        types = (entry.symbols || []).filter(symbol =>
+            OWNER_CLASS_KINDS.has(symbol.type) && !symbol.aliasOf);
+        state.lexicalTypes.set(entry, types);
+    }
+    const containing = types.filter(type => type !== definition &&
+        type.startLine <= definition.startLine &&
+        type.endLine >= (definition.endLine ?? definition.startLine));
+    const width = type => type.endLine - type.startLine;
+    const narrowest = Math.min(...containing.map(width));
+    const candidates = containing.filter(type => width(type) === narrowest).map(type =>
+        classDefsNamed(index, type.name).entries.find(entry => entry.def === type)).filter(Boolean);
+    const chosen = candidates.length === 1 ? candidates[0] : null;
+    // Equal line ranges can belong to different same-line type bodies.
+    // Keep that ambiguity distinct from an out-of-line type declaration.
+    const ref = chosen ? { name: chosen.def.name, key: chosen.key, def: chosen.def }
+        : containing.length ? { name: null, key: null, def: null } : null;
+    state.lexicalOwners.set(definition, ref);
+    return ref;
+}
+
 /**
  * The class definition a member is declared in, when the language's own
  * scoping makes that certain (fix #389): the innermost same-name type body
@@ -389,7 +525,9 @@ function ownerDefinitionOf(index, member) {
     const state = _state(index);
     if (state.ownerDefs.has(member)) return state.ownerDefs.get(member);
     const defs = (index.symbols.get(name) || []).filter(d => d && d !== member &&
-        d.name === name && OWNER_CLASS_KINDS.has(d.type) && d.file === member.file);
+        d.name === name && OWNER_CLASS_KINDS.has(d.type) && d.file === member.file &&
+        (member.namespace == null || (d.namespace || null) === member.namespace) &&
+        (member.enclosingType == null || (d.enclosingType || null) === member.enclosingType));
     const span = d => d.endLine - d.startLine;
     const containing = (list, line, endLine = line) => list.filter(d =>
         d.startLine <= line && d.endLine >= endLine);
@@ -515,7 +653,8 @@ function parentRefsOf(index, ref) {
     const out = [];
     const seen = new Set();
     const push = parent => {
-        const k = parent.key || `?${parent.name}${parent.external ? '!' : ''}`;
+        const k = parent.key || `?${parent.name}${parent.external ? '!' : ''}` +
+            (parent.alternatives ? `#${parent.alternatives.map(alternative => alternative.key).join('#')}` : '');
         if (seen.has(k)) return;
         seen.add(k);
         out.push(parent);
@@ -541,8 +680,32 @@ function parentRefsOf(index, ref) {
         // language's own disambiguation. Re-read it from the declared clause.
         const rawParents = decl.extends ? splitParentList(decl.extends) : [];
         const declRef = { name: ref.name, key: ref.key, def: decl };
+        if (langTraits(index.files.get(contextFile)?.language)?.memberLookupOrder === 'c3') {
+            // Python's base order is semantic. Resolving imported bases as
+            // a separate group would move them ahead of earlier bases.
+            for (const written of rawParents) {
+                const imported = _importBoundParents(index, contextFile, [written], ref);
+                if (imported.refs.length) { imported.refs.forEach(push); continue; }
+                if (written.includes('.')) {
+                    push(_resolveQualifiedParent(index, written, contextFile, declRef));
+                } else {
+                    push(externalParentDenotation(index, contextFile, written, decl.startLine) ||
+                        resolveClassRef(index, written, contextFile, {
+                            excludeKey: written === ref.name ? ref.key : null,
+                            line: decl.startLine,
+                        }));
+                }
+            }
+            continue;
+        }
+        // A base the module binds by import where names bind per runtime
+        // configuration (Python, fix #424): the import's own chase decides
+        // which class it is (`from .auto import tqdm as base`, where auto
+        // binds `tqdm` to a class or another module's value per branch).
+        const imported = _importBoundParents(index, contextFile, rawParents, ref);
+        for (const parent of imported.refs) push(parent);
         for (const parentName of names || []) {
-            if (!parentName) continue;
+            if (!parentName || imported.names.has(parentName)) continue;
             const qualified = parentName.includes('::') || parentName.includes('.');
             if (qualified && classDefsNamed(index, parentName).entries.length === 0) {
                 push(_resolveQualifiedParent(index, parentName, contextFile, declRef));
@@ -580,6 +743,134 @@ function parentRefsOf(index, ref) {
     return out;
 }
 
+/**
+ * Bases a Python declaration spells by a name its module binds by a
+ * module-level import (fix #424). Each candidate class definition of the
+ * imported name is asked whether the import's module chase reaches it under
+ * that name: one definite hit is the base; a hit through one configuration
+ * alternative, a module value or no project class leave it unresolved
+ * (key null). A chase the index cannot follow keeps the name lookup.
+ * Returns the resolved refs and the inheritance-graph names they cover.
+ */
+function _importBoundParents(index, contextFile, rawParents, childRef) {
+    const out = { refs: [], names: new Set() };
+    const fileEntry = contextFile ? index.files.get(contextFile) : null;
+    if (!fileEntry || langTraits(fileEntry.language)?.conditionalDefinitions !== 'branch' ||
+        rawParents.length === 0) return out;
+    const { _nameBindingReaches } = require('./callers');
+    for (const written of rawParents) {
+        if (!/^[A-Za-z_]\w*$/.test(written)) continue;
+        const bindings = (fileEntry.importBindings || []).filter(b => b.module != null && b.name !== '*' &&
+            b.kind !== 'import' && (b.alias || b.name) === written &&
+            !(Number.isInteger(b.line) && index.findEnclosingFunction(contextFile, b.line, true)));
+        if (bindings.length !== 1) continue;
+        const binding = bindings[0];
+        const rel = fileEntry.moduleResolved?.[binding.module];
+        if (!rel) continue;
+        const moduleFile = path.isAbsolute(rel) ? rel : path.join(index.root, rel);
+        let entries = classDefsNamed(index, binding.name).entries.filter(e => !e.def.lexicalScopeStartLine);
+        if (binding.name === childRef.name && childRef.key) entries = entries.filter(e => e.key !== childRef.key);
+        if (entries.length === 0) continue;
+        const verdicts = entries.map(e => _nameBindingReaches(index, moduleFile, binding.name, new Set([e.def.file]), 4,
+            { targetName: binding.name, configurationVerdict: true, valueVerdict: true }));
+        if (verdicts.includes('unknown')) continue;
+        const hits = entries.filter((e, i) => verdicts[i] === 'yes');
+        out.names.add(binding.name);
+        if (hits.length === 1 && verdicts.filter(v => v !== 'no').length === 1) {
+            out.refs.push({ name: binding.name, key: hits[0].key, def: hits[0].def });
+            continue;
+        }
+        // One class per runtime configuration (fix #434): members every
+        // alternative declares through one definition are known by name.
+        const alternatives = _pythonClassDenotations(index, moduleFile, binding.name, 0);
+        if (alternatives?.length === 1 && hits.length === 0) {
+            out.refs.push(_refOfDefinition(index, alternatives[0]));
+            continue;
+        }
+        out.refs.push({ name: binding.name, key: null, def: null, importUnresolved: true,
+            ...(alternatives?.length > 1 && { alternatives: alternatives.map(def => _refOfDefinition(index, def)) }) });
+    }
+    return out;
+}
+
+function _refOfDefinition(index, def) {
+    const entry = classDefsNamed(index, def.name).entries.find(candidate => candidate.def === def);
+    return { name: def.name, key: entry?.key || null, def };
+}
+
+/**
+ * The class definitions a Python module-scope name denotes, one per runtime
+ * configuration (fix #434): a class statement, a value naming a class, an
+ * import of a class, or a configuration item whose every alternative is
+ * one of those. Null when any alternative is no class or cannot be followed.
+ */
+function _pythonClassDenotations(index, file, name, depth) {
+    const entry = index.files.get(file);
+    if (!entry || depth > 6 || !/^[A-Za-z_]\w*$/.test(String(name))) return null;
+    const classAt = line => {
+        const found = classDefsNamed(index, name).entries.filter(candidate => candidate.def.file === file &&
+            !candidate.def.className && candidate.def.lexicalScopeStartLine == null &&
+            (line == null || candidate.def.startLine === line || candidate.def.nameLine === line));
+        return found.length === 1 ? found[0].def : null;
+    };
+    const imported = (target, line = null) => {
+        const bindings = (entry.importBindings || []).filter(binding => binding.module != null &&
+            binding.name !== '*' && binding.kind !== 'import' && (binding.alias || binding.name) === target &&
+            (line == null || binding.line === line));
+        if (bindings.length !== 1) return null;
+        const rel = entry.moduleResolved?.[bindings[0].module];
+        if (!rel) return null;
+        return _pythonClassDenotations(index, path.isAbsolute(rel) ? rel : path.join(index.root, rel),
+            bindings[0].name, depth + 1);
+    };
+    const { moduleItemNamed } = require('./configuration-items');
+    const item = moduleItemNamed(index, file, name);
+    if (item) {
+        const out = [];
+        for (const site of item.sites) {
+            let defs = null;
+            if (site.kind === 'class') {
+                const def = classAt(site.line);
+                defs = def ? [def] : null;
+            } else if (site.kind === 'value' && site.target) {
+                defs = site.target === name ? null : _pythonClassDenotations(index, file, site.target, depth + 1);
+            } else if (site.kind === 'import') {
+                defs = imported(name, site.line);
+            }
+            if (!defs) return null;
+            for (const def of defs) if (!out.includes(def)) out.push(def);
+        }
+        return out.length > 0 ? out : null;
+    }
+    const own = classAt(null);
+    if (own) return [own];
+    if ((entry.symbols || []).some(def => def.name === name && !def.className && def.lexicalScopeStartLine == null &&
+        def.type !== 'state')) return null;
+    const alias = (entry.moduleValueAliases || []).filter(value => value.name === name);
+    if (alias.length === 1 && alias[0].target && !alias[0].alternatives?.length && alias[0].target !== name &&
+        !alias[0].target.includes('.')) return _pythonClassDenotations(index, file, alias[0].target, depth + 1);
+    if (alias.length > 0) return null;
+    return imported(name);
+}
+
+/**
+ * The member lookup every configuration alternative of a base agrees on
+ * (fix #434): the declaring class and members when each alternative finds
+ * the same definitions certainly, else null.
+ */
+function alternativesDeclare(index, ref, definitions, opts = {}) {
+    if (!ref?.alternatives?.length) return null;
+    let agreed = null;
+    for (const alternative of ref.alternatives) {
+        const found = _findDeclaringClass(index, alternative, definitions, { ...opts, parentsOnly: false });
+        if (!found || found.uncertain) return null;
+        if (!agreed) { agreed = found; continue; }
+        if (found.members.length !== agreed.members.length ||
+            found.members.some(member => !agreed.members.includes(member))) return null;
+    }
+    return agreed;
+}
+
 /**
  * An unqualified base name the declaring file binds to an out-of-project
  * type (fix #390): an external reference (or an unresolved one when the
@@ -819,6 +1110,54 @@ function _findDeclaringClass(index, startRef, definitions, opts) {
         }
         return members.length > 0 ? { ref, uncertain, members } : null;
     };
+    if (langTraits(index.files.get(startRef.def?.file)?.language)?.memberLookupOrder === 'c3') {
+        if (!opts.parentsOnly) { const own = check(startRef); if (own) return own; }
+        const order = c3Order(index, startRef);
+        if (order) {
+            for (const ref of order.slice(opts.parentsOnly ? 1 : 0)) {
+                const hit = check(ref);
+                if (hit) return hit;
+            }
+            return null;
+        }
+        // Even an incomplete order starts with the class and its first
+        // direct base. A single-base chain preserves that prefix. Once
+        // branches merge, unknown ancestry can change which member wins.
+        const seen = new Set();
+        let ref = startRef, skip = opts.parentsOnly;
+        while (ref?.key && ref.def && !ref.external && !seen.has(ref.key)) {
+            seen.add(ref.key);
+            if (!skip) { const hit = check(ref); if (hit) return hit; }
+            skip = false;
+            const parents = parentRefsOf(index, ref);
+            if (parents.length === 1) { ref = parents[0]; continue; }
+            if (parents.length > 1 && parents[0].key && parents[0].def && !parents[0].external) {
+                const hit = check(parents[0]);
+                if (hit) return hit;
+            }
+            break;
+        }
+        // A fully resolved project closure ending only in known external
+        // bases cannot reach an unrelated project namesake. Keep that
+        // negative identity proof; uncertainty in ORDER matters only when
+        // a project member or an unresolved base can participate.
+        const pending = opts.parentsOnly ? [...parentRefsOf(index, startRef)] : [startRef];
+        const visited = new Set();
+        let possible = false;
+        while (pending.length) {
+            const candidate = pending.shift();
+            if (candidate.external || visited.has(_refVisitKey(candidate))) continue;
+            visited.add(_refVisitKey(candidate));
+            if (!candidate.key || !candidate.def || candidate.importUnresolved || check(candidate)) {
+                possible = true;
+                break;
+            }
+            pending.push(...parentRefsOf(index, candidate));
+        }
+        if (!possible) return null;
+        return alternativesDeclare(index, ref, definitions, opts) ||
+            { ref: ref || startRef, uncertain: true, members: [] };
+    }
     const visited = new Set([_refVisitKey(startRef)]);
     if (!opts.parentsOnly) {
         const own = check(startRef);
@@ -831,6 +1170,12 @@ function _findDeclaringClass(index, startRef, definitions, opts) {
         const vk = _refVisitKey(ref);
         if (visited.has(vk)) continue;
         visited.add(vk);
+        // A base its import leaves undecided (fix #424) may declare the
+        // member under any class name.
+        if (ref.importUnresolved) {
+            return alternativesDeclare(index, ref, definitions, opts) ||
+                { ref, uncertain: true, members: check(ref)?.members || [] };
+        }
         const hit = check(ref);
         if (hit) {
             // An unresolved parent can only yield an uncertain match.
@@ -853,6 +1198,30 @@ function _findDeclaringClass(index, startRef, definitions, opts) {
     return null;
 }
 
+/** Complete C3 order, or null when a base's ancestry is unknown. */
+function c3Order(index, ref, visiting = new Set()) {
+    if (!ref?.key || !ref.def || ref.external || visiting.has(ref.key)) return null;
+    const memo = _state(index).linearizations;
+    if (memo.has(ref.key)) return memo.get(ref.key);
+    visiting.add(ref.key);
+    const parents = parentRefsOf(index, ref);
+    const lists = parents.map(parent => c3Order(index, parent, visiting)?.slice());
+    visiting.delete(ref.key);
+    if (lists.some(list => !list)) { memo.set(ref.key, null); return null; }
+    lists.push(parents.slice());
+    const order = [ref];
+    while (lists.some(list => list.length)) {
+        const active = lists.filter(list => list.length);
+        const head = active.map(list => list[0]).find(candidate =>
+            !active.some(list => list.slice(1).some(item => item.key === candidate.key)));
+        if (!head) { memo.set(ref.key, null); return null; }
+        order.push(head);
+        for (const list of active) if (list[0].key === head.key) list.shift();
+    }
+    memo.set(ref.key, order);
+    return order;
+}
+
 /**
  * Relationship of class reference `ref` to the owners of `targetDefs`:
  * 'same' (identical definition), 'ancestor' (ref is a transitive ancestor of
@@ -929,6 +1298,14 @@ function descendsFromTargets(index, ref, targetDefs) {
         if (visited.has(vk)) continue;
         visited.add(vk);
         if (matches(parent)) return 'yes';
+        if (parent.alternatives?.length) {
+            // A base per runtime configuration (fix #434) descends when
+            // every alternative does.
+            const verdicts = parent.alternatives.map(alternative => descendsFromTargets(index, alternative, targetDefs));
+            if (verdicts.every(verdict => verdict === 'yes')) return 'yes';
+            if (!verdicts.every(verdict => verdict === 'no')) maybe = true;
+            continue;
+        }
         if (parent.key || parent.def) {
             queue.push(...parentRefsOf(index, parent));
         } else {
@@ -996,6 +1373,11 @@ function shareDescendant(index, matchedRef, targetDefs) {
     for (const td of targetDefs) {
         const tRef = ownerRefOf(index, td);
         if (!tRef) continue;
+        if (!tRef.key) return true;
+        // A leaf has no proper descendant that can combine the two
+        // owners. If it belongs to the target's descendants, the existing
+        // below-target rule skips it; otherwise the sets cannot intersect.
+        if (mine.size === 1) continue;
         const theirs = descendantKeys(index, tRef);
         if (!theirs) return true;
         if (theirs.has(matchedRef.key)) continue;
@@ -1006,13 +1388,18 @@ function shareDescendant(index, matchedRef, targetDefs) {
 
 module.exports = {
     OWNER_CLASS_KINDS,
+    alternativesDeclare,
+    pythonClassDenotations: _pythonClassDenotations,
     resetClassIdentity,
     ownerNameOf,
     classKeyOf,
     classDefsNamed,
+    completeForwardDeclaration,
+    forwardDeclarationProvider,
     resolveClassRef,
     resolveQualifiedClassRef: _resolveQualifiedParent,
     ownerRefOf,
+    lexicalClassRefOf,
     ownerDefinitionOf,
     distinctOwnerDefinitions,
     hasFunctionLocalClass,