gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -20,6 +20,8 @@
  * as-is for TypeScript, Java, Kotlin, Ruby, etc.
  */
 import { normalizeQualifiedName, splitQualifiedName, stripTrailingTypeArguments, } from '../../utils/qualified-name.js';
+import { extractTemplateArguments, stripTemplateArguments, } from '../../utils/template-arguments.js';
+import { definitionIdPosition } from '../utils/definition-id.js';
 const EMPTY_BINDINGS = Object.freeze([]);
 /**
  * Look up binding refs at `scopeId` for `name`, consulting both the
@@ -163,11 +165,155 @@ export function isClassLike(t) {
         t === 'Enum' ||
         t === 'Trait');
 }
+/**
+ * Does this label declare MEMBERS addressable by name?
+ *
+ * `isClassLike` answers two questions that only coincide for classes:
+ *   1. does this declare members I can look up?  — a SHAPE (structural)
+ *   2. does this participate in inheritance / MRO? — a NOMINAL TYPE
+ *
+ * A TypeScript object-type alias answers YES to (1) and emphatically NO to
+ * (2): it declares the same `property_signature` members as the interface
+ * beside it, but has no supertypes and no place in a linearization. Answering
+ * (2) "yes" merely to buy (1) is what widening `isClassLike` would do, and it
+ * would enrol every language's aliases (Rust `type_item`, Kotlin/Swift/Dart
+ * typealias, C `typedef`) into MRO and heritage.
+ *
+ * So the two questions get two predicates. Use THIS one where the question is
+ * "find the shape so I can look up a member"; keep `isClassLike` where the
+ * question is inheritance. The call sites announce which they are:
+ * `resolveInheritanceBaseInScope` and `resolveQualifiedInheritanceBase` are
+ * (2); receiver typing is (1).
+ *
+ * NOT YET INCLUDED, deliberately: `Typedef` and `Union`. They belong here
+ * conceptually — the `union_item` note on `MEMBER_OWNER_NODE_TYPES` records
+ * the same gap, that a union owns fields captured as `Property` yet is not a
+ * recognized owner — but neither is wired as a member container today, so
+ * adding them would widen a predicate nothing exercises. They join when their
+ * containers do, with fixtures.
+ */
+export function isShapeLike(t) {
+    return isClassLike(t) || t === 'TypeAlias';
+}
 /**
  * Walk the scope chain from `startScope` looking for a typeBinding
  * named `receiverName`. Returns the TypeRef or undefined if no binding
  * exists in the chain.
+ *
+ * A scope that declares `ownsReceivers.has(receiverName)` terminates the
+ * walk with `undefined` (#2701): it binds that receiver itself, so an
+ * enclosing scope's binding is not visible through it. The check runs
+ * AFTER this scope's own `typeBindings`, so a scope that both owns and
+ * binds the receiver — a class method, which is where `this` is bound TO
+ * the class — still resolves normally. The namespace/global fallbacks
+ * below are also skipped: they answer "which type is named X", which is a
+ * different question from "what is this scope's receiver", and reaching
+ * them for an owned-but-unbound receiver is how a static method or a
+ * detached callback acquires a fabricated one.
+ */
+/**
+ * True when `receiverName` is DEFINITIVELY unresolvable at `startScope`:
+ * a scope on the chain declares it owns that receiver (`Scope.ownsReceivers`)
+ * and carries no type binding for it (#2701).
+ *
+ * This is a stronger statement than `findReceiverTypeBinding` returning
+ * `undefined`, which only means "no type found" — an ordinary miss that later
+ * passes are free to resolve by other means. Here the language has said the
+ * receiver is REBOUND at this scope, so no enclosing type can be its type:
+ * `this.m()` inside a nested JS/TS `function` is a call on whatever the
+ * function is invoked with, which the graph does not model. A member call
+ * whose receiver is unresolvable in this sense must be suppressed rather
+ * than left to the receiver-blind lexical fallback in `lookupCore`, which
+ * would find the enclosing class's member by name alone.
+ *
+ * Returns false for every language that leaves `ownsReceivers` unset.
+ */
+export function isReceiverOwnedButUnbound(startScope, receiverName, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return false;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return false;
+        if (scope.typeBindings.has(receiverName))
+            return false;
+        if (scope.ownsReceivers?.has(receiverName) === true)
+            return true;
+        currentId = scope.parent;
+    }
+    return false;
+}
+/**
+ * True when a declaration between the call site and its module scope shadows a
+ * file-level namespace import of the same name. Namespace targets are collected
+ * per FILE, so every consumer of that map must apply this lexical guard before
+ * trusting it at an inner scope — otherwise `def f(pkg): pkg.db.query()`
+ * resolves through the import that the parameter shadows, producing a wrong
+ * edge rather than a missing one.
+ *
+ * A namespace key may itself be a dotted import path (`pkg.db`, #2826), but the
+ * name a declaration can shadow is always the ROOT identifier — `pkg = Decoy()`
+ * shadows `pkg.db` too. Testing the whole dotted string would never match a
+ * binding, so the guard would silently stop guarding for exactly the keys it
+ * was extended to cover. Single-segment names are unaffected: their root is
+ * themselves.
+ *
+ * Fails closed (returns `true`) on a missing scope or a parent cycle: for every
+ * caller, suppressing a resolution costs a missing edge, while trusting a
+ * corrupt scope chain costs a wrong one.
+ *
+ * Reads `scope.bindings` DIRECTLY rather than through `lookupBindingsAt`, and
+ * that is deliberate — the opposite of the fix #2745 applied to Rust's
+ * `headBoundLocally`. There the question was "is this name bound at all?", so
+ * missing the finalized/augmented import channels lost real bindings. Here the
+ * question is "does something LOCAL shadow the import?", and the import's own
+ * finalized binding is the one thing that must NOT count: routing this through
+ * `lookupBindingsAt` would find the namespace import shadowing itself and
+ * suppress every namespace receiver in the workspace. Locals, parameters and
+ * lexical names all live in the scope's own tables, which is exactly the set
+ * this walk wants.
  */
+export function isNamespaceNameShadowed(namespaceName, inScope, scopes) {
+    const firstDot = namespaceName.indexOf('.');
+    const rootName = firstDot === -1 ? namespaceName : namespaceName.slice(0, firstDot);
+    let currentId = inScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return true;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return true;
+        // Stop AT the module scope without inspecting it. In languages where a
+        // namespace import IS a variable declaration — CommonJS
+        // `const svc = require('./svc')` — the import puts its own name into the
+        // module scope's tables, so inspecting them reads the import as its own
+        // shadow and suppresses every receiver it was meant to enable (#2723).
+        // The contract is "a declaration BETWEEN the call site and its module
+        // scope", and the module scope is the floor, not a rung.
+        if (scope.kind === 'Module')
+            return false;
+        if (scope.kind !== 'Object' &&
+            (scope.bindings.has(rootName) ||
+                scope.typeBindings.has(rootName) ||
+                scope.lexicalNames?.has(rootName) === true ||
+                scope.ownedDefs.some((def) => {
+                    const qualifiedName = def.qualifiedName;
+                    if (qualifiedName === undefined)
+                        return false;
+                    const dot = qualifiedName.lastIndexOf('.');
+                    return (dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1)) === rootName;
+                }))) {
+            return true;
+        }
+        currentId = scope.parent;
+    }
+    return true;
+}
 export function findReceiverTypeBinding(startScope, receiverName, scopes) {
     let currentId = startScope;
     const visited = new Set();
@@ -182,6 +328,8 @@ export function findReceiverTypeBinding(startScope, receiverName, scopes) {
         const typeRef = scope.typeBindings.get(receiverName);
         if (typeRef !== undefined)
             return typeRef;
+        if (scope.ownsReceivers?.has(receiverName) === true)
+            return undefined;
         if (scope.kind === 'Module')
             moduleScopeId = currentId;
         currentId = scope.parent;
@@ -258,7 +406,248 @@ export function moduleScopeIdOf(startScope, scopes) {
  *
  * Without (2) we'd miss every cross-file class-receiver call.
  */
-export function findClassBindingInScope(startScope, receiverName, scopes) {
+/**
+ * Every class-like definition visible for `name`, from the scope chain AND the
+ * qualified-name index, deduped by `nodeId`.
+ *
+ * Exists because `walkScopeChain` returns the FIRST match and cannot report a
+ * collision, so a caller that widens what a name can match (the decoration
+ * normalizer below) has no way to tell "one answer" from "picked the nearest of
+ * several". Mirrors `findAllCallableBindingsInScope`, which solved the same
+ * problem for callables.
+ */
+export function findAllClassBindingsInScope(startScope, name, scopes) {
+    return classBindingsVisibleFrom(lexicalClassBindingsInScope(startScope, name, scopes), name, scopes);
+}
+/**
+ * {@link findAllClassBindingsInScope} for a caller that already holds the
+ * scope-chain half (see {@link lexicalClassBindingsInScope}), so the chain is
+ * walked once rather than once per question asked about the same name.
+ *
+ * The chain wins outright when it binds the name: an inner binding shadows
+ * anything the qualified-name index would contribute.
+ */
+function classBindingsVisibleFrom(lexical, name, scopes) {
+    if (lexical.length > 0)
+        return lexical;
+    const byNodeId = new Map();
+    for (const def of classDefsByQualifiedName(name, scopes))
+        byNodeId.set(def.nodeId, def);
+    return [...byNodeId.values()];
+}
+/** Bounded so a pathological stripper cannot spin. Real decoration nests
+ *  shallowly (`*[]T`, `const T&`); three layers is generous. */
+const MAX_DECORATION_LAYERS = 3;
+/** Memo for {@link typeParameterNamesInScope}, keyed by index bundle then
+ *  scope. One bundle per model, so the outer WeakMap releases with it. */
+const typeParameterNamesByBundle = new WeakMap();
+const NO_TYPE_PARAMETERS = Object.freeze(new Set());
+/**
+ * Did `def` OPEN `scope` — i.e. is this scope the declaration's own body?
+ *
+ * The gate on reading a declaration's `typeParameters` as a lexical binding.
+ * `ownedDefs` answers "which scope was this declaration written in", which is a
+ * DIFFERENT question: a declaration that opens no scope of its own is owned by
+ * whatever encloses it, and reading its parameters there binds them across that
+ * entire enclosing region.
+ *
+ * Measured (#2899): a TypeScript `type Maybe<Result> = Result | null` opens no
+ * scope — only the `object_type` alias form does — so its parameter list landed
+ * in the MODULE's `ownedDefs`. Since each scope's answer is built from its
+ * parent's, `Result` was then bound as a type parameter in every scope in the
+ * file, and the `USES` guard downstream deleted every genuine edge to the
+ * `interface Result` beside it, imported ones included. One un-anchored
+ * parameter list silently emptied an entire file of the edge class that answers
+ * "what breaks if I remove this field?".
+ *
+ * Compares the def's declaration position with the scope's start — the same
+ * alignment test `pickCallerCallableDef` uses to tell a closure from a nested
+ * function, and sound for the same reason: when a declaration is itself the
+ * scope node, both sides are built from one `Range`. Every language that
+ * populates `typeParameters` today anchors them on a declaration that IS a scope
+ * node (TS class/interface/function, Java/C#/Kotlin/Rust type declarations, the
+ * C++ `class_specifier` inside a `template_declaration`), so the alignment holds
+ * wherever the parameters were meant to bind.
+ *
+ * A `Module` scope is excluded outright rather than left to the position test:
+ * a module is opened by the file, never by a declaration, and a declaration
+ * written on the file's first line shares its start coordinates.
+ */
+function declarationOpenedScope(def, scope) {
+    if (scope.kind === 'Module')
+        return false;
+    const position = definitionIdPosition(def.nodeId, def.filePath);
+    if (position === undefined)
+        return false;
+    return position.line === scope.range.startLine && position.column === scope.range.startCol;
+}
+/**
+ * Every name the scope chain above `scopeId` (inclusive) binds as a declared
+ * TYPE PARAMETER.
+ *
+ * Memoized per scope, and each scope's answer is built from its PARENT's, so a
+ * chain is walked once and every scope on it is O(own defs) rather than
+ * O(depth × defs). That matters because the caller runs on every class-binding
+ * lookup, and a module scope's `ownedDefs` is the whole file.
+ *
+ * That parent-inheriting fold is also why {@link declarationOpenedScope} gates
+ * every read: a parameter list picked up one scope too high does not merely
+ * over-reach by one scope, it reaches every scope below it as well.
+ */
+function typeParameterNamesInScope(scopeId, scopes) {
+    let byScope = typeParameterNamesByBundle.get(scopes);
+    if (byScope === undefined) {
+        byScope = new Map();
+        typeParameterNamesByBundle.set(scopes, byScope);
+    }
+    const memo = byScope.get(scopeId);
+    if (memo !== undefined)
+        return memo;
+    // Collect the chain first, then fold from the top down, so the recursion is
+    // an explicit loop (a deep scope chain must not risk the call stack) and
+    // every scope passed through is memoized on the way back.
+    const chain = [];
+    const seen = new Set();
+    let cursor = scopeId;
+    let inherited = NO_TYPE_PARAMETERS;
+    while (cursor !== null && !seen.has(cursor)) {
+        seen.add(cursor);
+        const cached = byScope.get(cursor);
+        if (cached !== undefined) {
+            inherited = cached;
+            break;
+        }
+        chain.push(cursor);
+        cursor = scopes.scopeTree.getScope(cursor)?.parent ?? null;
+    }
+    for (let i = chain.length - 1; i >= 0; i -= 1) {
+        const id = chain[i];
+        const scope = scopes.scopeTree.getScope(id);
+        let own;
+        for (const def of scope?.ownedDefs ?? []) {
+            if (def.typeParameters === undefined)
+                continue;
+            if (scope === undefined || !declarationOpenedScope(def, scope))
+                continue;
+            for (const parameter of def.typeParameters) {
+                if (parameter.name.length === 0)
+                    continue;
+                own ??= new Set(inherited);
+                own.add(parameter.name);
+            }
+        }
+        inherited = own ?? inherited;
+        byScope.set(id, inherited);
+    }
+    return inherited;
+}
+/**
+ * Does the scope chain at `scopeId` bind `name` as a declared TYPE PARAMETER?
+ *
+ * The question a class-binding lookup has to ask before it answers, because a
+ * type parameter and a class are spelled identically and only the declaration
+ * says which one a name is. `class Box<T> { t: T }` beside a workspace
+ * `export class T` resolved `t` to the CLASS and emitted a confident wrong edge
+ * from every member call on `t` — the exact failure mode this subsystem treats
+ * as worse than a missing edge.
+ *
+ * WHY LEXICAL GROUNDING CANNOT SUBSTITUTE. The erasure grounds in
+ * `resolveErasedBaseName` all ask "can the file SEE a declaration by this
+ * name", and here it plainly can: `export class T` is imported, bound, and
+ * lexically visible. Visibility is not the defect — the name means something
+ * else at this site regardless of what else is visible, and only the enclosing
+ * declaration's parameter list records that. Measured: with the grounding rule
+ * in place the false edge still emitted.
+ *
+ * ABSENCE IS NOT EVIDENCE. `typeParameters` is populated only by the languages
+ * whose captures were extended for it, and is absent both for a non-generic
+ * declaration and for every declaration in a language that does not populate it
+ * yet. So only a POSITIVE match declines; an absent list changes nothing, which
+ * is what keeps every unconverted language behaving exactly as it does today.
+ */
+export function bindsTypeParameter(scopeId, name, scopes) {
+    if (name.length === 0)
+        return false;
+    return typeParameterNamesInScope(scopeId, scopes).has(name);
+}
+/**
+ * The declared parameter `name` refers to at `scopeId`, nearest declaration
+ * first, or `undefined` when `name` is not a type parameter here.
+ *
+ * Separate from {@link bindsTypeParameter} because the guard only needs to know
+ * THAT a name is a parameter, while resolving through a bound needs the
+ * parameter itself — and the memoized name set deliberately keeps no payload so
+ * that the guard, which runs on every lookup, stays a single hash probe.
+ */
+function typeParameterAt(scopeId, name, scopes) {
+    let cursor = scopeId;
+    const seen = new Set();
+    while (cursor !== null && !seen.has(cursor)) {
+        seen.add(cursor);
+        const scope = scopes.scopeTree.getScope(cursor);
+        for (const def of scope?.ownedDefs ?? []) {
+            const hit = def.typeParameters?.find((parameter) => parameter.name === name);
+            if (hit !== undefined)
+                return hit;
+        }
+        cursor = scope?.parent ?? null;
+    }
+    return undefined;
+}
+/**
+ * The single class-like name a declared bound names, or `undefined` when the
+ * bound names none or names more than one.
+ *
+ * DECLINING ON AN INTERSECTION is the point. `T extends Repo & Closeable` and
+ * `T: Repo + Clone` make a member reachable through EITHER bound, so picking one
+ * — the first, as erasure would — mints a confidently-attributed edge to a
+ * declaration that may not own the member at all. Two candidates and no way to
+ * choose is exactly the case this file already answers with `undefined` in
+ * `findClassBindingInScope`'s decoration fallback: a missing edge is
+ * recoverable, a wrong one is not.
+ *
+ * Type ARGUMENTS on the bound are erased (`T extends Repo<User>` → `Repo`),
+ * which is sound here for the same reason the erased base-name route exists: the
+ * members are declared once, on the declaration written against its parameters.
+ */
+function soleBoundBaseName(bound) {
+    // `&` (Java, TypeScript) and `+` (Rust, Kotlin) both compose bounds. Split on
+    // whichever appears OUTSIDE brackets, so `Repo<A & B>` stays one bound.
+    let depth = 0;
+    for (let i = 0; i < bound.length; i += 1) {
+        const ch = bound[i];
+        if (ch === '<' || ch === '(' || ch === '[' || ch === '{')
+            depth += 1;
+        else if (ch === '>' || ch === ')' || ch === ']' || ch === '}')
+            depth -= 1;
+        else if (depth === 0 && (ch === '&' || ch === '+'))
+            return undefined;
+    }
+    const base = stripTemplateArguments(bound).trim();
+    return base.length === 0 ? undefined : base;
+}
+export function findClassBindingInScope(startScope, receiverName, scopes, 
+/**
+ * OPT-IN. When supplied, a name that binds nothing is retried with decoration
+ * stripped one layer at a time, and each retry must resolve to exactly ONE
+ * class-like definition or it declines.
+ *
+ * Opt-in rather than global because roughly two dozen call sites use the shape
+ * `findClassBindingInScope(...) ?? otherResolver(...)`: turning a former
+ * `undefined` into a hit SUPPRESSES the fallback that used to answer, which
+ * would retarget inheritance edges and bypass generic-specialization
+ * selection. Only receiver-chain base and step resolution passes this.
+ */
+stripDecoration) {
+    // A TYPE PARAMETER is not a class, and it is checked before every route below
+    // rather than inside one of them because each route would otherwise reach a
+    // same-named class by its own channel: the scope chain when the class is
+    // imported, the qualified-name index when it is not, and the decoration
+    // fallback after stripping. The declaration that introduced the parameter is
+    // the only thing that knows, and it knows for all three.
+    if (bindsTypeParameter(startScope, receiverName, scopes)) {
+        return resolveThroughTypeParameterBound(startScope, receiverName, scopes, stripDecoration);
+    }
     const local = walkScopeChain(startScope, receiverName, scopes, (def) => isClassLike(def.type));
     if (local !== undefined)
         return local;
@@ -285,6 +674,404 @@ export function findClassBindingInScope(startScope, receiverName, scopes) {
             }
         }
     }
+    // Decoration fallback (opt-in). Every branch above works on the name exactly
+    // as written; only when none of them bound anything do we consider that the
+    // name may be a decorated spelling of one that would.
+    if (stripDecoration !== undefined) {
+        let current = receiverName;
+        for (let layer = 0; layer < MAX_DECORATION_LAYERS; layer++) {
+            const stripped = stripDecoration(current);
+            if (stripped === undefined || stripped === current || stripped.length === 0)
+                break;
+            current = stripped;
+            const candidates = findAllClassBindingsInScope(startScope, current, scopes);
+            // Exactly one, or decline. Two same-named classes reachable from here mean
+            // the decoration was carrying the only disambiguating information, and
+            // picking the nearest would mint a confident wrong edge — the failure this
+            // whole line of work exists to avoid. A missing edge is recoverable.
+            if (candidates.length === 1)
+                return candidates[0];
+            if (candidates.length > 1)
+                return undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * What a TYPE PARAMETER used in type position resolves to — its declared BOUND
+ * when it states exactly one, and nothing when it is unbounded.
+ *
+ * `class Box<T extends Repo> { t: T; run() { this.t.save(); } }` has one sound
+ * answer for `this.t.save()`: the member set a `T` is GUARANTEED to have is its
+ * bound's, so `Repo.save` is the target the declaration itself licenses. An
+ * unbounded `class Box2<T>` licenses nothing — `T` has no members — and gets
+ * `undefined`, which is the whole of the Gap-C fix.
+ *
+ * ONE HOP ONLY. The retry is guarded against a bound that is itself a parameter
+ * (`class Box<T extends U, U extends Repo>`), so the recursion cannot chain or
+ * cycle. Following such a chain is sound in principle but has no measured case
+ * behind it, and an unbounded step in the middle would have to decline anyway.
+ */
+function resolveThroughTypeParameterBound(startScope, parameterName, scopes, stripDecoration) {
+    const bound = typeParameterAt(startScope, parameterName, scopes)?.bound;
+    if (bound === undefined)
+        return undefined;
+    const baseName = soleBoundBaseName(bound);
+    if (baseName === undefined || baseName === parameterName)
+        return undefined;
+    // A bound naming another parameter terminates here rather than recursing.
+    if (bindsTypeParameter(startScope, baseName, scopes))
+        return undefined;
+    return findClassBindingInScope(startScope, baseName, scopes, stripDecoration);
+}
+function normalizeTemplateArgToken(value) {
+    return value.replace(/\s+/g, '');
+}
+/**
+ * A definition that pins its OWN concrete type arguments (`templateArguments`
+ * is set) — the shape a scope extractor records for a declaration written
+ * against particular arguments rather than against its parameters, e.g. C++
+ * `template <> struct Vec<bool>` (`['bool']`) or `template <class T> struct
+ * Vec<T*>` (`['T*']`).
+ *
+ * The distinction that matters to the lookup below: such a definition serves
+ * exactly ONE family of instantiations, so the only sound way to select it is
+ * the exact-argument match. A declaration written against its parameters —
+ * `template <class T> struct Vec`, `class Repo<T>` in TypeScript, C# and every
+ * other language measured — carries NOTHING here (the extractor reads arguments
+ * off the declared name, and the name is bare), which is precisely why it can
+ * never win that match and must be reachable by the base-name route instead.
+ */
+function carriesOwnTemplateArguments(def) {
+    return def.templateArguments !== undefined && def.templateArguments.length > 0;
+}
+/** Class-like defs registered in the workspace-wide qualified-name index under
+ *  `name`. Workspace-WIDE: no scope filtering, so a caller must treat this as
+ *  the weaker source and prefer lexically visible candidates. */
+function classDefsByQualifiedName(name, scopes) {
+    const out = [];
+    for (const id of scopes.qualifiedNames.get(name)) {
+        const def = scopes.defs.get(id);
+        if (def !== undefined && isClassLike(def.type))
+            out.push(def);
+    }
+    return out;
+}
+/** Defs from `candidates` whose own template arguments equal `wantedArgs`
+ *  token-for-token (whitespace already squeezed on both sides). */
+function matchingTemplateArguments(candidates, wantedArgs) {
+    return candidates.filter((def) => {
+        const defArgs = def.templateArguments?.map(normalizeTemplateArgToken);
+        return (defArgs !== undefined &&
+            defArgs.length === wantedArgs.length &&
+            defArgs.every((value, i) => value === wantedArgs[i]));
+    });
+}
+/**
+ * Class-like defs the SCOPE CHAIN binds for `name` — locals, imports, wildcards,
+ * namespace siblings; everything `findAllBindingsInScope` reaches. No
+ * workspace-index fallback, which is the entire point: this is the set that
+ * answers "can the file see a declaration by this name", and
+ * `findAllClassBindingsInScope` deliberately cannot answer it because it falls
+ * through to the scope-free index when the chain is silent.
+ */
+function lexicalClassBindingsInScope(startScope, name, scopes) {
+    return findAllBindingsInScope(startScope, name, scopes, (def) => isClassLike(def.type));
+}
+/**
+ * The one declaration among `candidates` written against its PARAMETERS rather
+ * than against particular arguments — or `undefined` when there is not exactly
+ * one.
+ *
+ * ORDER-INDEPENDENT by construction, and that is why it exists separately from
+ * "take the first": an unordered candidate set (the workspace index, whose order
+ * is insertion order) must never let source order decide a call target. The
+ * scope-chain route keeps its nearest-first answer; only the index routes use
+ * this.
+ */
+function theInstantiationAgnosticDeclaration(candidates) {
+    const parameterized = candidates.filter((def) => !carriesOwnTemplateArguments(def));
+    return parameterized.length === 1 ? parameterized[0] : undefined;
+}
+/** Memo for {@link bindsAnyCrossFileClass}, keyed by index bundle then module
+ *  scope. One bundle per model, so the outer WeakMap releases with it. */
+const crossFileClassChannelByBundle = new WeakMap();
+/**
+ * Does the FILE containing `scopeId` bind, at its module scope, any class-like
+ * definition declared in a DIFFERENT file?
+ *
+ * This is the question "is a name's absence from this file's scope chain
+ * evidence of anything", and it has to be asked of the data because the answer
+ * differs per language while the scope model records no fact that says which.
+ * Both halves were MEASURED on this pipeline, not assumed:
+ *
+ *   - A C++ `#include` materializes NO binding. Two files declaring `Repo`, one
+ *     of them `#include`d by the referencing file, resolves to NEITHER — the
+ *     include contributed nothing and the ambiguity was decided by the
+ *     workspace-wide index alone. So a C++ file's chain binds nothing
+ *     cross-file, and the index is the only channel it has.
+ *   - A TypeScript `import` does bind, and so does a C# `using` (through the
+ *     accessible-namespace channel).
+ *
+ * So "the chain does not bind `Map`" is real evidence in a TypeScript file and
+ * no evidence at all in a C++ one. Asking the data which kind of file this is
+ * keeps the rule out of the business of naming languages (AGENTS.md R6).
+ *
+ * FAILS TOWARD PERMISSIVE. `false` — no module scope, no file path, nothing
+ * cross-file bound — restores exactly the import-blind behaviour that predates
+ * this check, so every way it can be wrong costs a wrong edge that already
+ * existed rather than a working edge that did not.
+ */
+function bindsAnyCrossFileClass(scopeId, scopes) {
+    const moduleScopeId = moduleScopeIdOf(scopeId, scopes);
+    if (moduleScopeId === null)
+        return false;
+    let byScope = crossFileClassChannelByBundle.get(scopes);
+    if (byScope === undefined) {
+        byScope = new Map();
+        crossFileClassChannelByBundle.set(scopes, byScope);
+    }
+    const memo = byScope.get(moduleScopeId);
+    if (memo !== undefined)
+        return memo;
+    const answer = scanForCrossFileClass(moduleScopeId, scopes);
+    byScope.set(moduleScopeId, answer);
+    return answer;
+}
+/**
+ * The uncached scan behind {@link bindsAnyCrossFileClass}. Answers on the FIRST
+ * hit, so a file with a wide `export *` surface stops at its first imported
+ * class rather than walking the surface; a file with none is walked in full, but
+ * its module scope then holds only its own declarations.
+ *
+ * Reads the binding CHANNELS rather than asking `lookupBindingsAt` once per
+ * name, because the question is existential and the per-name route answers a
+ * question it does not need: a module scope activates the accessibility-gated
+ * namespace channel, so every one of N bound names re-probed all K accessible
+ * namespaces (75.6 ms for one C#-shaped file at N=5,000, K=1,000) and paid
+ * `lookupBindingsAt`'s merge allocation each time. The population considered is
+ * identical — the two per-scope channels' own buckets, plus the namespace and
+ * workspace channels under exactly the names those two bind.
+ */
+function scanForCrossFileClass(moduleScopeId, scopes) {
+    const filePath = scopes.scopeTree.getScope(moduleScopeId)?.filePath;
+    if (filePath === undefined)
+        return false;
+    const bindsCrossFileClass = (refs) => refs !== undefined &&
+        refs.some((ref) => isClassLike(ref.def.type) && ref.def.filePath !== filePath);
+    // The two per-scope channels, read as whole buckets. An ordinary import lands
+    // here, so this is where the early exit usually fires.
+    const finalized = scopes.bindings.get(moduleScopeId);
+    const augmented = scopes.bindingAugmentations.get(moduleScopeId);
+    for (const channel of [finalized, augmented]) {
+        for (const refs of channel?.values() ?? []) {
+            if (bindsCrossFileClass(refs))
+                return true;
+        }
+    }
+    const boundNameCount = (finalized?.size ?? 0) + (augmented?.size ?? 0);
+    if (boundNameCount === 0)
+        return false;
+    const bindsName = (name) => finalized?.has(name) === true || augmented?.has(name) === true;
+    // Materialized once, not per channel — `namesAtScope` allocates when both
+    // per-scope channels are populated.
+    let boundNames;
+    const namesBoundHere = () => (boundNames ??= [...namesAtScope(moduleScopeId, scopes)]);
+    // The accessibility-gated namespace channel: ONE lookup per accessible
+    // namespace, then whichever of the two sides is smaller is the one iterated —
+    // so neither a namespace with a large type table nor a file with many bound
+    // names can reintroduce the product.
+    for (const ns of scopes.accessibleNamespacesByScope?.get(moduleScopeId) ?? []) {
+        const inNamespace = scopes.namespaceFqnBindings?.get(ns);
+        if (inNamespace === undefined || inNamespace.size === 0)
+            continue;
+        if (inNamespace.size <= boundNameCount) {
+            for (const [name, refs] of inNamespace) {
+                if (bindsName(name) && bindsCrossFileClass(refs))
+                    return true;
+            }
+        }
+        else {
+            for (const name of namesBoundHere()) {
+                if (bindsCrossFileClass(inNamespace.get(name)))
+                    return true;
+            }
+        }
+    }
+    // The scope-independent workspace channel is keyed by name alone and has no
+    // per-scope bucket to walk, so it stays a probe per bound name.
+    const workspace = scopes.workspaceFqnBindings;
+    if (workspace !== undefined && workspace.size > 0) {
+        for (const name of namesBoundHere()) {
+            if (bindsCrossFileClass(workspace.get(name)))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Resolve a class-like binding for a declared type name, tolerating a spelling
+ * that carries TYPE ARGUMENTS (`Repo<User>`, `Vec<int>`) where the declaration
+ * itself is registered under the bare base name.
+ *
+ * Two normalizations, and they are not the same thing:
+ *
+ *   1. DECORATION stripping (`stripDecoration`, opt-in — see the parameter).
+ *      Peels type-PRESERVING wrappers (`*T`, `const T&`) off the name.
+ *   2. Type-argument ERASURE (unconditional, and the wider of the two).
+ *      `Repo<User>` → `Repo`. This is what actually widens what binds, because
+ *      it makes one declaration answer for EVERY instantiation of it — right
+ *      for a language where a generic class has a single declaration, and a
+ *      hazard where it does not, which is why the exact-argument match runs
+ *      first and why the base-name route below refuses to return a
+ *      declaration that pinned its own arguments.
+ *
+ * Order: exact spelling → exact type-argument match (lexically visible
+ * candidates first, workspace-wide index second) → base name.
+ */
+export function resolveClassBindingForName(scopeId, rawClassName, scopes, 
+/**
+ * OPT-IN, and it governs (1) only — argument erasure happens either way.
+ * `findClassBindingInScope`'s own docstring explains the opt-in: a name that
+ * previously bound nothing starts binding, which SUPPRESSES the
+ * `?? otherResolver(...)` fallbacks several callers rely on.
+ *
+ * THE RULE, not a roll-call of who currently passes it (that list has been
+ * appended to once per round of this work and is stale the moment it is
+ * written): pass it from a receiver-TYPING site, and only where the site
+ * already forwarded the same `stripTypePreservingDecoration` to the bare
+ * lookup — so a Go pointer receiver keeps resolving exactly as it did. A site
+ * that has never stripped must keep calling without it, because starting to
+ * strip is what suppresses its fallback.
+ */
+stripDecoration) {
+    const direct = findClassBindingInScope(scopeId, rawClassName, scopes, stripDecoration);
+    if (direct !== undefined)
+        return direct;
+    // NO object-type-ALIAS fallback here, and that is a decision rather than an
+    // omission. This function carried one before #2833 moved it out of
+    // `passes/receiver-bound-calls.ts`; the move dropped it, and re-applying it at
+    // merge time turned out to be wrong twice over. It is unexercised — deleting
+    // it fails no test, because alias MEMBERS resolve through the precise path
+    // instead (`type_alias_declaration value: (object_type)` emits `@scope.class`,
+    // so a typed receiver reaches the shape's own scope). And re-adding it
+    // unconditionally walked straight past the type-parameter refusal #2833 had
+    // just introduced, re-opening through an alias the exact false edge that
+    // change closed — their `neg-type-parameter` fixture caught it.
+    //
+    // If a future case genuinely needs it, it must be gated on
+    // `bindsTypeParameter` and land with a test that fails without it.
+    if (!rawClassName.includes('<'))
+        return undefined;
+    const baseName = stripTemplateArguments(rawClassName).replace(/\s+/g, '');
+    if (baseName.length === 0)
+        return undefined;
+    // The class-like defs the SCOPE CHAIN binds for the base name. Computed once
+    // and used twice — it is the lexical half of "what can the base name see from
+    // here" AND ground (1) of the erasure rule below, and the two asked for it
+    // separately, bottoming out in the same walk for a third of the cost of every
+    // lookup whose declared type carries type arguments.
+    const lexical = lexicalClassBindingsInScope(scopeId, baseName, scopes);
+    const wantedArgs = extractTemplateArguments(rawClassName)?.map(normalizeTemplateArgToken);
+    if (wantedArgs !== undefined && wantedArgs.length > 0) {
+        // LEXICAL FIRST. The workspace-wide index is not scoped, so matching against
+        // it up front let a field inside `namespace N` be answered by the GLOBAL
+        // `Box<bool>` — or, when both namespaces declare one, by neither: two
+        // matches, a decline, and a fall through to whatever base-name declaration
+        // the walk reached first. Candidates the scope chain actually offers are
+        // ranked ahead of it, exactly as every other lookup in this file does.
+        const lexicalMatches = matchingTemplateArguments(classBindingsVisibleFrom(lexical, baseName, scopes), wantedArgs);
+        if (lexicalMatches.length === 1)
+            return lexicalMatches[0];
+        if (lexicalMatches.length === 0) {
+            // Workspace-wide fallback — consulted ONLY when the scope chain offered no
+            // exact match, which is how a declaration specialized in a different file
+            // than the one instantiating it still binds.
+            const indexMatches = matchingTemplateArguments(classDefsByQualifiedName(baseName, scopes), wantedArgs);
+            if (indexMatches.length === 1)
+                return indexMatches[0];
+        }
+    }
+    // ── Base-name route ────────────────────────────────────────────────────────
+    // Nothing matched the arguments as written, so what is left to find is the
+    // declaration written against its PARAMETERS — the one instantiation-agnostic
+    // declaration the erasure is entitled to reach.
+    return resolveErasedBaseName(scopeId, baseName, scopes, lexical);
+}
+/**
+ * The declaration an ERASED base name is entitled to reach — the counterpart of
+ * `findClassBindingInScope` for a name that lost its type arguments, and the one
+ * place the grounding rule for that erasure lives.
+ *
+ * GROUNDING is the whole difference between a fix and a fabrication. Erasure
+ * makes ONE declaration answer for EVERY instantiation of a name, so reaching it
+ * by NAME ALONE is the widest step in this file: it is why `Map<string, User>`
+ * bound a workspace `class Map` the file cannot see, and why a third-party
+ * `Mapped[User]` bound an unrelated workspace `class Mapped` — a family of
+ * confident wrong edges the language interpreters have been holding back with
+ * deny-lists over an open universe of names. The name is not evidence. One of
+ * four grounds must connect the site to the declaration, strongest first.
+ */
+function resolveErasedBaseName(scopeId, baseName, scopes, 
+/**
+ * Ground (1) below, already computed: {@link lexicalClassBindingsInScope} for
+ * `baseName` at `scopeId`. A parameter rather than a call because the only
+ * caller needs the same list for its exact-argument match, and computing it
+ * twice walked the scope chain twice.
+ */
+lexical) {
+    // (1) THE SCOPE CHAIN binds the base name — a local, an import, a wildcard, a
+    // namespace sibling. The file demonstrably sees a declaration by that name, so
+    // erasing to it is what the source meant.
+    if (lexical.length > 0) {
+        const nearest = lexical[0];
+        // The walk landed on a declaration that pinned its own arguments — arguments
+        // the branch above just proved are NOT the ones written. It won on nothing
+        // but being reached first: `Vec<int> vi` bound the `Vec<bool>`
+        // specialization when the specialization happened to be declared above the
+        // primary template, and the primary when it did not. Source order deciding a
+        // call target is a wrong edge, not a missing one. Re-decide over the same
+        // visible candidates with those declarations removed.
+        return carriesOwnTemplateArguments(nearest)
+            ? theInstantiationAgnosticDeclaration(lexical)
+            : nearest;
+    }
+    // Nothing lexical. Both remaining grounds read the workspace-wide qualified-
+    // name index, which consults no scope, no import and no module — so each one
+    // has to supply the connection the index itself cannot.
+    const indexed = classDefsByQualifiedName(baseName, scopes);
+    // (2) THE DECLARATION IS IN THIS VERY FILE. A same-file declaration is visible
+    // to the site in every language — no import, no `using`, no `#include` — which
+    // is exactly what makes this ground language-neutral rather than a guess. It
+    // is also load-bearing rather than theoretical: a member typed `ns::Repo<User>`
+    // resolves through here, because the qualifier is dropped at capture and a
+    // sibling NAMESPACE is not on the file's scope chain.
+    const siteFile = scopes.scopeTree.getScope(scopeId)?.filePath;
+    const sameFile = siteFile === undefined ? [] : indexed.filter((def) => def.filePath === siteFile);
+    if (sameFile.length > 0)
+        return theInstantiationAgnosticDeclaration(sameFile);
+    // (3) THE INDEX PROVES THE NAME IS A TEMPLATE FAMILY — some declaration under
+    // it pins its own arguments. That is the same evidence the exact-argument
+    // index match above already acts on, and acting on it in only one direction
+    // was incoherent: in one measured fixture `Vec<bool>` bound the cross-file
+    // SPECIALIZATION through the index while `Vec<int>` bound nothing, though both
+    // are equally import-blind and the primary template is the only declaration
+    // that can answer `int`.
+    //
+    // (4) …or THE FILE HAS NO CROSS-FILE CHANNEL to be absent from, in which case
+    // the index is not a shortcut around the scope chain — it is the only channel
+    // that file has, and refusing it deletes every cross-file generic in the
+    // languages whose visibility is not lexical. Measured, both directions: a C++
+    // `#include` binds nothing, so `Repo<User>` in a `.cpp` reaches its header
+    // declaration ONLY here; a TypeScript `import` binds, so a file that imports
+    // anything and still cannot see `Map` genuinely cannot see it.
+    //
+    // Between them these two grounds are what separates the fix from the
+    // fabrication: `Map`, `Queue`, `Deque` in a file with a working import channel
+    // offer nothing but a spelling, and now get nothing.
+    if (indexed.some(carriesOwnTemplateArguments) || !bindsAnyCrossFileClass(scopeId, scopes)) {
+        return theInstantiationAgnosticDeclaration(indexed);
+    }
     return undefined;
 }
 /**
@@ -555,6 +1342,19 @@ export function isOwnableValueLabel(t) {
 export function findValueBindingInScope(startScope, receiverName, scopes) {
     return walkScopeChain(startScope, receiverName, scopes, (def) => isOwnableValueLabel(def.type));
 }
+/**
+ * Look up a SHAPE binding (class-like, or an object-type alias) by name.
+ *
+ * Mirrors `findClassBindingInScope` exactly; only the accepted def-type
+ * predicate differs — the same relationship `findValueBindingInScope` has to
+ * it. Exists so a receiver typed as an object-type alias can reach that
+ * alias's members WITHOUT the alias becoming eligible as an inheritance base:
+ * `findClassBindingInScope` is what `resolveInheritanceBaseInScope` calls, so
+ * widening that one would answer a question about hierarchies with a shape.
+ */
+export function findShapeBindingInScope(startScope, receiverName, scopes) {
+    return walkScopeChain(startScope, receiverName, scopes, (def) => isShapeLike(def.type));
+}
 /**
  * Generic scope-chain walker. Walks from `startScope` toward the root,
  * consulting both the local `scope.bindings` channel and the dual-source
@@ -614,6 +1414,59 @@ function walkScopeChain(startScope, name, scopes, predicate) {
 export function findCallableBindingInScope(startScope, callableName, scopes) {
     return findAllCallableBindingsInScope(startScope, callableName, scopes)[0];
 }
+function collectCallableBindingCandidates(sources) {
+    const byNodeId = new Map();
+    for (const source of sources) {
+        if (source === undefined)
+            continue;
+        for (const binding of source) {
+            const def = binding.def;
+            if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+                continue;
+            const existing = byNodeId.get(def.nodeId);
+            if (existing === undefined) {
+                byNodeId.set(def.nodeId, { def, bindings: [binding] });
+            }
+            else {
+                existing.bindings.push(binding);
+            }
+        }
+    }
+    return [...byNodeId.values()];
+}
+/**
+ * Binding-aware callable lookup for consumers that need visibility evidence.
+ * Unlike `lookupBindingsAt`, duplicate definitions retain every binding path,
+ * so a weaker augmentation can contribute provenance even when a finalized
+ * binding remains the candidate's canonical definition.
+ */
+export function findAllCallableBindingCandidatesInScope(startScope, callableName, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return [];
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return [];
+        if (scope.kind !== 'Object') {
+            const lexical = collectCallableBindingCandidates([scope.bindings.get(callableName)]);
+            if (lexical.length > 0)
+                return lexical;
+            const candidates = collectCallableBindingCandidates([
+                scopes.bindings.get(currentId)?.get(callableName),
+                scopes.bindingAugmentations.get(currentId)?.get(callableName),
+                collectNamespaceFqnBindings(currentId, callableName, scopes),
+                scopes.workspaceFqnBindings?.get(callableName),
+            ]);
+            if (candidates.length > 0)
+                return candidates;
+        }
+        currentId = scope.parent;
+    }
+    return [];
+}
 /**
  * Look up all callable bindings (Function/Method/Constructor) by name
  * from the nearest scope in the chain that binds `callableName`.
@@ -622,7 +1475,24 @@ export function findCallableBindingInScope(startScope, callableName, scopes) {
  * `findCallableBindingInScope`: once any callable binding is found in a
  * scope, outer scopes are not consulted.
  */
-export function findAllCallableBindingsInScope(startScope, callableName, scopes) {
+/**
+ * Every definition visible for `name` at the NEAREST scope that binds it,
+ * filtered by `predicate` and deduped by `nodeId`.
+ *
+ * THE shared "collect all at the nearest binding scope" walk. `walkScopeChain`
+ * answers the first-match question; this answers the how-many question, which is
+ * what a caller needs before it can decline on ambiguity.
+ *
+ * Stops at the first scope that binds the name at all: an inner binding SHADOWS
+ * an outer one, so continuing would report a shadowed outer definition as a
+ * competing candidate and decline a name that is unambiguous at this point.
+ *
+ * Returns `[]` on a cycle or a missing scope. That is deliberate and matters:
+ * an earlier copy of this walk `break`-ed instead and fell through to a
+ * qualified-name fallback, so the same malformed input produced a different
+ * answer depending on which copy the caller happened to reach.
+ */
+function findAllBindingsInScope(startScope, name, scopes, predicate) {
     let currentId = startScope;
     const visited = new Set();
     while (currentId !== null) {
@@ -637,24 +1507,19 @@ export function findAllCallableBindingsInScope(startScope, callableName, scopes)
         if (scope.kind !== 'Object') {
             const out = [];
             const seen = new Set();
-            const pushCallable = (def) => {
-                if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+            const push = (def) => {
+                if (!predicate(def))
                     return;
                 if (seen.has(def.nodeId))
                     return;
                 seen.add(def.nodeId);
                 out.push(def);
             };
-            const localBindings = scope.bindings.get(callableName);
-            if (localBindings !== undefined) {
-                for (const b of localBindings) {
-                    pushCallable(b.def);
-                }
-            }
-            const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
-            for (const b of importedBindings) {
-                pushCallable(b.def);
-            }
+            // Local first: a binding in this scope shadows an imported one.
+            for (const b of scope.bindings.get(name) ?? [])
+                push(b.def);
+            for (const b of lookupBindingsAt(currentId, name, scopes))
+                push(b.def);
             if (out.length > 0)
                 return out;
         }
@@ -662,6 +1527,9 @@ export function findAllCallableBindingsInScope(startScope, callableName, scopes)
     }
     return [];
 }
+export function findAllCallableBindingsInScope(startScope, callableName, scopes) {
+    return findAllBindingsInScope(startScope, callableName, scopes, (def) => def.type === 'Function' || def.type === 'Method' || def.type === 'Constructor');
+}
 /**
  * ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when ordinary
  * unqualified lookup finds:
@@ -789,13 +1657,19 @@ export function populateClassOwnedMembers(parsed) {
     // on `class U: def save(self): def helper(): ...` — helper.ownerId will
     // remain undefined. The theoretical concern is real only if the
     // extractor ever stops creating scopes for inner defs.
+    // `isShapeLike`, not `isClassLike`: OWNERSHIP is question (1) — "which
+    // declaration do these members belong to?" — and an object-type alias owns
+    // members exactly as the interface beside it does. Without this its members
+    // get no `ownerId`, so nothing is registered under the alias and a receiver
+    // typed as one finds the owner but never its members. Inheritance/MRO keep
+    // `isClassLike`; see the predicate's docstring.
     for (const scope of parsed.scopes) {
         // Methods: function scope whose parent is a Class scope. Owner is
-        // the parent's class-like def.
+        // the parent's shape def.
         if (scope.parent !== null) {
             const parentScope = scopesById.get(scope.parent);
             if (parentScope !== undefined && parentScope.kind === 'Class') {
-                const classDef = parentScope.ownedDefs.find((d) => isClassLike(d.type));
+                const classDef = parentScope.ownedDefs.find((d) => isShapeLike(d.type));
                 if (classDef !== undefined) {
                     for (const def of scope.ownedDefs) {
                         def.ownerId = classDef.nodeId;
@@ -807,7 +1681,7 @@ export function populateClassOwnedMembers(parsed) {
         // Class-body fields: defs directly owned by a Class scope (the
         // class-like def itself excluded).
         if (scope.kind === 'Class') {
-            const classDef = scope.ownedDefs.find((d) => isClassLike(d.type));
+            const classDef = scope.ownedDefs.find((d) => isShapeLike(d.type));
             if (classDef !== undefined) {
                 for (const def of scope.ownedDefs) {
                     if (def === classDef)
@@ -839,7 +1713,16 @@ export function populateClassOwnedMembers(parsed) {
  * for nested namespaces regardless of whether the inner namespace's name is
  * stored simple or already dotted. Skips defs already carrying the prefix.
  */
-export function tagNamespacePrefixes(parsed) {
+export function tagNamespacePrefixes(parsed, options = {}) {
+    // Whether a def's `qualifiedName` may ALREADY encode its enclosing namespace.
+    // Where it can (C++, C#), a name equal to — or prefixed by — the namespace path
+    // must not be tagged again. Where it cannot, that guard misreads a coincidence:
+    // a Rust `mod a { pub fn a() }` has `qualifiedName === 'a'` purely because the
+    // item and its module share a name, and skipping it leaves the member looking
+    // like it belongs to the PARENT module.
+    const alreadyQualified = options.qualifiedNamesCarryNamespace === undefined
+        ? true
+        : options.qualifiedNamesCarryNamespace;
     const scopesById = new Map();
     for (const scope of parsed.scopes)
         scopesById.set(scope.id, scope);
@@ -874,8 +1757,8 @@ export function tagNamespacePrefixes(parsed) {
             const q = def.qualifiedName;
             if (q === undefined || q.length === 0)
                 continue;
-            if (q === prefix || q.startsWith(`${prefix}.`))
-                continue; // already namespaced
+            if (alreadyQualified && (q === prefix || q.startsWith(`${prefix}.`)))
+                continue;
             def.namespacePrefix = prefix;
         }
     }
@@ -902,8 +1785,8 @@ export function tagNamespacePrefixes(parsed) {
             const q = def.qualifiedName;
             if (q === undefined || q.length === 0)
                 continue;
-            if (q === fullPrefix || q.startsWith(`${fullPrefix}.`))
-                continue; // already namespaced
+            if (alreadyQualified && (q === fullPrefix || q.startsWith(`${fullPrefix}.`)))
+                continue;
             if (def.namespacePrefix !== undefined)
                 continue;
             def.namespacePrefix = fullPrefix;