ucn 5.5.1 → 5.5.2

package/core/provenance.js

@@ -7,6 +7,13 @@ const isOffset = value => Number.isFinite(value) && value >= 0;
 
 const { codeUnitCompare } = require('./shared');
 
+// Modules read lazily (load cycles), each resolved once: a require() per
+// call in hot paths was measurable (fix #436).
+let lazyProvenanceOverloadModuleCache = null;
+const lazyProvenanceOverloadModule = () => lazyProvenanceOverloadModuleCache || (lazyProvenanceOverloadModuleCache = require('./provenance-overload'));
+let lazyReceiverTypesModuleCache = null;
+const lazyReceiverTypesModule = () => lazyReceiverTypesModuleCache || (lazyReceiverTypesModuleCache = require('./receiver-types'));
+
 const TYPE_SOURCE_RULES = Object.freeze({
     annotation: 'receiver-annotation', constructor: 'constructor-typed',
     flow: 'return-flow', field: 'field-hop', literal: 'literal-receiver',
@@ -85,6 +92,124 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         ? { verdict: 'establishes-target' }
         : { verdict: 'establishes-other', declaration };
     if (!targets.length || targets.some(t => !validIdentity(t))) return incomplete('missing-target-identity');
+    if (facts.implicitBaseBinding) {
+        const owner = facts.implicitBaseBinding.binding?.owner;
+        return validIdentity(owner) && require('./provenance-constructor-base').validateImplicitBase(facts.implicitBaseBinding, owner, facts.site)
+            ? verdictFor(owner) : incomplete('unproven-implicit-base');
+    }
+    if (facts.constructionBinding) {
+        const owner = facts.constructionBinding.owner;
+        return validIdentity(owner) && require('./provenance-type').validateTypeLookup(facts.constructionBinding, owner, facts.site)
+            ? verdictFor(owner) : incomplete('unproven-construction-type');
+    }
+    if (facts.constructorCall) {
+        const constructor = facts.constructorCall;
+        const { owner, members, selected, classBinding, call, overload } = constructor;
+        const constructed = constructor.constructedOwner || owner;
+        // A same-type delegation (`this(...)`) runs in one of the owner's
+        // constructors, which is never its target: Java JLS 8.8.7, C#
+        // CS0516, C++ [class.base.init] (fix #419).
+        const delegating = constructor.delegating;
+        // The parts of a C# partial type are one type (fix #430): a member
+        // lies in one of them. Every part names the owner's type.
+        const parts = constructor.parts === undefined ? [owner] : constructor.parts;
+        if (constructor.parts !== undefined && (!Array.isArray(parts) || !validIdentity(owner) ||
+            !parts.some(part => sameDeclaration(part, owner)) ||
+            parts.some(part => !validIdentity(part) || part.name !== owner.name || part.kind !== owner.kind ||
+                (part.namespace || null) !== (owner.namespace || null) ||
+                (part.enclosingType || null) !== (owner.enclosingType || null)))) {
+            return inconsistent('constructor-owner-mismatch');
+        }
+        const inPart = def => parts.some(part => def.file === part.file &&
+            def.startLine >= part.startLine && def.endLine <= part.endLine);
+        if (delegating !== undefined) {
+            const site = facts.site;
+            // An out-of-class definition (fix #421) holds the site and
+            // defines the in-class declaration: same owner scope path and
+            // parameter signature.
+            const body = constructor.delegatingDefinition || delegating;
+            const scopePath = def => [def.namespace, def.enclosingType].filter(Boolean).join('::');
+            if (!validIdentity(owner) || !validIdentity(delegating) || call?.delegation !== 'this' ||
+                call.syntax !== 'delegation' || delegating.kind !== 'constructor' ||
+                delegating.className !== owner.name || !inPart(delegating) ||
+                (delegating.namespace || null) !== (owner.namespace || null) ||
+                !site || site.file !== body.file || site.line < body.startLine || site.line > body.endLine ||
+                (members || []).some(member => sameDeclaration(member, delegating))) {
+                return inconsistent('constructor-delegation-mismatch');
+            }
+            if (constructor.delegatingDefinition && (!validIdentity(body) || body.kind !== 'constructor' ||
+                body.className !== owner.name || body.name !== delegating.name ||
+                scopePath(body) !== [owner.namespace, owner.enclosingType].filter(Boolean).join('::') ||
+                typeof body.signature !== 'string' || body.signature !== constructor.delegatingSignature)) {
+                return inconsistent('constructor-delegation-mismatch');
+            }
+            if (targets.every(t => sameDeclaration(t, delegating))) {
+                return { verdict: 'establishes-other', declaration: delegating, diagnostic: 'constructor-delegation-self' };
+            }
+        }
+        const structural = require('../languages').langTraits(facts.language)?.typeSystem === 'structural';
+        if (!validIdentity(owner) || !validIdentity(selected) || !Array.isArray(members) || !members.length ||
+            !call || !(call.isConstructor || require('../languages').langTraits(facts.language)?.classesCallableWithoutNew ||
+                require('../languages').langTraits(facts.language)?.functionalTypeConstruction) ||
+            call.isFunctionReference || call.isPotentialCallback) return incomplete('missing-constructor-facts');
+        if (!classBinding?.facts?.site || classBinding.facts.site.file !== facts.site?.file ||
+            classBinding.facts.site.line !== facts.site?.line ||
+            classBinding.facts.site.column !== facts.site?.column ||
+            (structural || validateConfirmation(classBinding, constructed).verdict !== 'establishes-target') &&
+                !require('./provenance-type').validateTypeLookup(constructor.typeLookup, constructed, facts.site)) {
+            return incomplete('unproven-construction-binding');
+        }
+        if (require('../languages').langTraits(facts.language)?.inheritedOverloadSignatures &&
+            overload?.call?.argumentFile !== facts.site?.file) {
+            return incomplete('unproven-construction-argument-source');
+        }
+        if (!structural && !['implicit', 'delegation', 'enum'].includes(call.syntax) &&
+            (constructor.nameScope?.query?.name !== overload?.call?.name ||
+                constructor.nameScope?.query?.qualifier !== (overload?.call?.constructorQualifier || overload?.call?.receiver || null) ||
+                !require('./provenance-type').validateTypeLookup(constructor.nameScope, constructed, facts.site))) {
+            return incomplete('unproven-construction-name-scope');
+        }
+        if (call.syntax === 'implicit') {
+            const base = classBinding.facts.implicitBaseBinding;
+            if (!base || !require('./provenance-constructor-base').validateImplicitBase(base, constructed, facts.site)) {
+                return incomplete('unproven-implicit-base');
+            }
+            if (base.base.potential) return incomplete('constructor-default-unresolved');
+        }
+        if (!sameDeclaration(owner, constructed) &&
+            !require('./constructor-hierarchy').validateHierarchy(constructor.hierarchy, constructed, owner, members)) {
+            return incomplete('unproven-constructor-inheritance');
+        }
+        const constructorProtocol = require('../languages').langTraits(facts.language)?.constructorProtocol;
+        if (members.some(member => (member.kind !== 'constructor' && member.name !== constructorProtocol?.initializer) || member.className !== owner.name ||
+            !inPart(member) ||
+            (member.namespace || null) !== (owner.namespace || null) ||
+            (member.enclosingType || null) !== (owner.enclosingType || null)) ||
+            !members.some(member => sameDeclaration(member, selected))) return inconsistent('constructor-owner-mismatch');
+        if (overload?.candidates?.some(def => def.type === 'constructor' &&
+            (!Array.isArray(def.modifiers) || def.modifiers.includes('static')))) {
+            return incomplete('constructor-instance-flags');
+        }
+        if (!call.isConstructor && require('../languages').langTraits(facts.language)?.functionalTypeConstruction) {
+            if (!(constructor.typeLookup?.query?.functional &&
+                require('./provenance-type').validateTypeLookup(constructor.typeLookup, owner, facts.site))) {
+                return incomplete('constructor-functional-binding');
+            }
+        }
+        const protocol = require('../languages').langTraits(facts.language)?.constructorProtocol;
+        if (protocol) {
+            if (!require('./constructor-protocol').validateConstructorProtocol(constructor.protocol, constructed, members, facts.language)) {
+                return incomplete('constructor-protocol-unresolved');
+            }
+        }
+        if (invalidCall && members.length !== 1) return incomplete('constructor-overload-unselected');
+        if (!require('../languages').langTraits(facts.language)?.hasArityOverloads && members.length > 1 &&
+            !overload?.candidates?.some(def => def.isSignature === true)) return incomplete('constructor-definition-ambiguous');
+        if (!lazyProvenanceOverloadModule().validateOverload(overload, members, selected, invalidCall, false, facts.site)) {
+            return incomplete('constructor-overload-unselected');
+        }
+        return verdictFor(selected);
+    }
     if (facts.receiverOrigin?.externalFactory) {
         const factory = facts.receiverOrigin.externalFactory;
         const empty = value => Array.isArray(value) && !value.length;
@@ -237,13 +362,33 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         }
     }
     if (facts.builtinReceiver) {
-        if (!require('./receiver-types').isProvenanceBuiltinReceiver(facts.receiverType, facts.language) ||
+        if (!lazyReceiverTypesModule().isProvenanceBuiltinReceiver(facts.receiverType, facts.language) ||
             facts.builtinReceiver.type !== facts.receiverType ||
             facts.builtinReceiver.language !== facts.language) return inconsistent('builtin-receiver-mismatch');
         if (!facts.receiverOrigin || ['unknown', 'guess'].includes(facts.receiverTypeSource) ||
             facts.receiverOrigin.source !== facts.receiverTypeSource) return incomplete('builtin-origin-not-established');
         return { verdict: 'establishes-other', declaration: { builtin: facts.receiverType, language: facts.language } };
     }
+    if (facts.typeReference) {
+        const reference = facts.typeReference;
+        if (!validIdentity(reference.declaration) || !reference.written ||
+            String(reference.written).split(/::|\./).pop() !== reference.declaration.name) {
+            return inconsistent('type-reference-mismatch');
+        }
+        return verdictFor(reference.declaration);
+    }
+    const castThis = facts.receiverCastThis;
+    if (castThis) {
+        const receiver = facts.lookup?.receiver;
+        if (!validIdentity(castThis.enclosing) || castThis.interfaceType !== facts.receiverType ||
+            (receiver && (castThis.enclosing.className !== receiver.name ||
+                castThis.enclosing.file !== receiver.file))) return inconsistent('receiver-this-cast-mismatch');
+        // Knowing the enclosing class does not prove the implementation an
+        // interface cast of this invokes. A subclass may reimplement it.
+        // This also applies when a qualified cast prevented member lookup:
+        // that missing lookup must not fall through as an unsupported proof.
+        return incomplete('receiver-this-cast-dispatch');
+    }
     if (facts.lookup) {
         const { receiver, steps, selected } = facts.lookup;
         if (!validIdentity(receiver) || !validIdentity(selected) || !Array.isArray(steps) || !steps.length) {
@@ -253,9 +398,15 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         if (!sameDeclaration(receiver, facts.receiverResolvedIn)) return inconsistent('receiver-identity-mismatch');
         const aliases = facts.receiverAliases || [];
         const typeDeclaration = facts.receiverTypeDeclaration || receiver;
+        // The written qualifier spells the declaration's enclosing type, its
+        // namespace, or (fix #430) its namespace and enclosing types, in full
+        // or from an enclosing namespace of the site.
+        const qualifiedPath = [typeDeclaration.namespace, typeDeclaration.enclosingType].filter(Boolean).join('.');
         if (facts.receiverTypeQualifier && ['java', 'csharp'].includes(facts.language) &&
             facts.receiverTypeQualifier !== typeDeclaration.enclosingType &&
-            facts.receiverTypeQualifier !== typeDeclaration.namespace) {
+            facts.receiverTypeQualifier !== typeDeclaration.namespace &&
+            !(typeDeclaration.enclosingType && (qualifiedPath === facts.receiverTypeQualifier ||
+                qualifiedPath.endsWith(`.${facts.receiverTypeQualifier}`)))) {
             return inconsistent('receiver-qualifier-mismatch');
         }
         if (facts.receiverImportChain && validateConfirmation({ facts: {
@@ -275,12 +426,8 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             !bound.bounds?.includes(typeDeclaration.name) || !sameDeclaration(bound.selected, typeDeclaration))) {
             return inconsistent('receiver-generic-bound-mismatch');
         }
-        const castThis = facts.receiverCastThis;
-        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;
-        const group = overload && require('./provenance-overload').overloadMemberGroup(steps);
+        const group = overload && lazyProvenanceOverloadModule().overloadMemberGroup(steps);
         if (overload && !group) return incomplete('missing-overload-declarations');
         if (overload && !group.some(member => sameDeclaration(declarationIdentity(member), selected))) {
             return inconsistent('selected-member-outside-overload-group');
@@ -301,15 +448,70 @@ function validateConfirmation(provenance, target, invalidCall = false) {
                 return incomplete('missing-member-lookup-facts');
             }
             const named = step.members.filter(member => member.name === selected.name);
+            const delegation = step.constructorDelegation;
+            if (delegation && (i !== 0 || facts.receiver !== 'super' || selected.kind !== 'constructor' ||
+                delegation.enclosing?.kind !== 'constructor' ||
+                delegation.enclosing.className !== step.owner.name ||
+                delegation.enclosing.file !== step.owner.file ||
+                facts.site?.line < delegation.enclosing.startLine || facts.site?.line > delegation.enclosing.endLine ||
+                !Array.isArray(delegation.members) || named.length ||
+                delegation.members.some(member => member.kind !== 'constructor' || member.className !== step.owner.name))) {
+                return inconsistent('constructor-delegation-mismatch');
+            }
+            // A super lookup (fix #428) passes over the enclosing class's
+            // own members: only the first step, for the language's super
+            // receiver inside a member of that class.
+            const superLookup = step.superLookup;
+            if (superLookup) {
+                const enclosing = facts.receiverOrigin?.declaration;
+                const keyword = require('../languages').langTraits(facts.language)?.superReceiver;
+                if (i !== 0 || !keyword || facts.receiver !== keyword || named.length ||
+                    facts.receiverOrigin?.source !== 'same-class' || facts.receiverOrigin.superLookup !== true ||
+                    !validIdentity(enclosing) || enclosing.className !== step.owner.name ||
+                    enclosing.file !== facts.site?.file || facts.site.line < enclosing.startLine ||
+                    facts.site.line > enclosing.endLine || !Array.isArray(superLookup.skipped) ||
+                    superLookup.skipped.some(member => member.className !== step.owner.name)) {
+                    return inconsistent('super-lookup-mismatch');
+                }
+            }
+            // The parts of a C# partial type declare one class's members.
+            const parts = Array.isArray(step.partialParts) ? step.partialParts : null;
+            if (parts && (facts.language !== 'csharp' || !parts.some(part => sameDeclaration(part, step.owner)) ||
+                parts.some(part => !validIdentity(part) || part.name !== step.owner.name || part.kind !== step.owner.kind ||
+                    (part.namespace || null) !== (step.owner.namespace || null) ||
+                    (part.enclosingType || null) !== (step.owner.enclosingType || null)))) {
+                return inconsistent('partial-part-mismatch');
+            }
             if (named.some(member => member.className !== step.owner.name ||
                 (member.namespace || null) !== (step.owner.namespace || null) ||
                 (member.enclosingType || null) !== (step.owner.enclosingType || null) ||
-                (facts.language !== 'go' && member.file !== step.owner.file))) {
+                (facts.language !== 'go' && member.file !== step.owner.file &&
+                    !parts?.some(part => part.file === member.file) &&
+                    // Rust impl blocks may sit in any file of the crate.
+                    !require('../languages').langTraits(facts.language)?.itemScopeResolution))) {
                 return inconsistent('member-owner-mismatch');
             }
             if (i + 1 < steps.length) {
                 if (named.length && !overload) return inconsistent('overriding-member-before-target');
-                if (!step.parents.some(parent => sameDeclaration(parent, steps[i + 1].owner))) {
+                const next = steps[i + 1];
+                if (next.enclosingOf) {
+                    // A lexical hop (fix #428): a bare call, a hierarchy that
+                    // ends here with no member of the name since the type
+                    // it started from, and the declaration enclosing it.
+                    const inner = next.enclosingOf;
+                    let start = 0;
+                    for (let j = i; j > 0; j--) if (steps[j].enclosingOf) { start = j; break; }
+                    const segments = String(inner?.enclosingType || '').split('.');
+                    const outerName = segments.pop();
+                    if (facts.receiver || facts.receiverOrigin?.source !== 'same-class' || !['java', 'csharp'].includes(facts.language) ||
+                        step.parents.length !== 0 || !validIdentity(inner) || !sameDeclaration(inner, steps[start].owner) ||
+                        steps.slice(start, i + 1).some(prior => prior.members.some(member => member.name === selected.name)) ||
+                        next.owner.name !== outerName || next.owner.file !== inner.file ||
+                        (next.owner.enclosingType || null) !== (segments.length ? segments.join('.') : null) ||
+                        next.owner.startLine > inner.startLine || (next.owner.endLine ?? next.owner.startLine) < inner.endLine) {
+                        return inconsistent('unproven-enclosing-hop');
+                    }
+                } else if (!step.parents.some(parent => sameDeclaration(parent, next.owner))) {
                     return inconsistent('unproven-inheritance-hop');
                 }
             } else if (configurationItem) {
@@ -328,13 +530,13 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             } else if (!overload && (named.length !== 1 || !sameDeclaration(named[0], selected))) {
                 const propertyRead = facts.valueReference && step.propertyRead &&
                     sameDeclaration(propertyReadMember(named), selected);
-                if (!propertyRead && !require('./provenance-overload').validateOverload(step.overload, named, selected)) {
+                if (!propertyRead && !lazyProvenanceOverloadModule().validateOverload(step.overload, named, selected, false, false, facts.site)) {
                     return incomplete('ambiguous-or-missing-member');
                 }
             }
         }
-        if (overload && !require('./provenance-overload').validateOverload(
-            overload, group.map(declarationIdentity), selected, invalidCall, ambiguousOverload)) {
+        if (overload && !lazyProvenanceOverloadModule().validateOverload(
+            overload, group.map(declarationIdentity), selected, invalidCall, ambiguousOverload, facts.site)) {
             return incomplete(overload.outcome === 'no-fit' ? 'no-applicable-overload' : 'ambiguous-or-missing-member');
         }
         if (facts.receiverTypeSource === 'guess' || facts.receiverTypeSource === 'unknown') {
@@ -348,7 +550,9 @@ function validateConfirmation(provenance, target, invalidCall = false) {
         }
         if (memberSetMembers) {
             if (targets.some(target => memberSetMembers.some(member => sameDeclaration(target, member)))) {
-                return incomplete('ambiguous-or-missing-member');
+                // A choice among them the replay cannot state (fix #428).
+                return facts.lookupGap ? { verdict: 'incomplete', diagnostic: facts.lookupGap, gap: true }
+                    : incomplete('ambiguous-or-missing-member');
             }
             return { verdict: 'establishes-other', declarations: memberSetMembers };
         }
@@ -411,6 +615,12 @@ function validateConfirmation(provenance, target, invalidCall = false) {
             last.declaration.name !== last.importedName) return incomplete('missing-import-declaration');
         return verdictFor(last.declaration);
     }
+    // A lookup this collector cannot state yet (fix #428: extension
+    // invocations, impl selection, members a using-declaration brings in,
+    // const/ref-qualified pairs, trait-provided methods, Rust name scopes)
+    // proves nothing: for exclusion and receiver migration it is incomplete,
+    // as before; on an edge another rule confirmed it reads `unsupported`.
+    if (facts.lookupGap) return { verdict: 'incomplete', diagnostic: facts.lookupGap, gap: true };
     // An unsupported rule is an instrumentation result, not a failed proof.
     // A collector that entered a supported lookup must still fail closed if
     // its witness is absent (including when a saved witness was tampered with).
@@ -420,6 +630,12 @@ function validateConfirmation(provenance, target, invalidCall = false) {
 
 /** An invalid member-family call is a diagnostic, never a confirmed edge. */
 function validateCallMismatch(provenance, target) {
+    const constructor = provenance?.facts?.constructorCall;
+    if (constructor) {
+        if (constructor.overload?.outcome !== 'no-fit' ||
+            !constructor.members?.some(member => sameDeclaration(member, target))) return false;
+        return validateConfirmation(provenance, constructor.members, true).verdict === 'establishes-target';
+    }
     const lookup = provenance?.facts?.lookup;
     if (lookup?.overload?.outcome !== 'no-fit') return false;
     const members = lookup.steps.flatMap(step => step.members || []);
@@ -433,13 +649,16 @@ function createProvenance(evidence, resolution) {
     const rules = [];
     if (evidence.possibleDispatch) rules.push('possible-dispatch');
     if (evidence.methodAmbiguous) rules.push('method-ambiguous');
-    if (evidence.resolvedBySameClass) rules.push('same-class');
+    // A qualified static call resolved to its class is type-qualified, not
+    // a same-class receiver (fix #428).
+    if (evidence.resolvedBySameClass && !evidence.qualifiedOwner) rules.push('same-class');
     if (evidence.extensionMethod) rules.push('extension-method');
     if (evidence.hasReceiverType || evidence.resolvedByReceiverHint) {
         rules.push(TYPE_SOURCE_RULES[source] || 'receiver-type');
     }
     if (evidence.typeQualifiedReceiver) rules.push('type-qualified');
     if (evidence.moduleOwnedPath) rules.push('module-owned');
+    if (evidence.itemScope) rules.push('item-scope');
     if (evidence.hasBindingId) rules.push('binding');
     if (evidence.hasSingleOwnerEvidence) rules.push('single-owner');
     if (evidence.hasImportEvidence) {
@@ -466,7 +685,7 @@ function createProvenance(evidence, resolution) {
     const provenance = { rule: rules[0], rules: [...new Set(rules)], facts };
     if (facts.targets?.length) {
         const checked = validateConfirmation(provenance, facts.targets);
-        provenance.validation = checked.verdict;
+        provenance.validation = checked.gap ? 'unsupported' : checked.verdict;
         if (checked.diagnostic) provenance.diagnostic = checked.diagnostic;
     } else {
         provenance.validation = 'incomplete';

package/core/public-command.js

@@ -5,8 +5,14 @@ const { CANONICAL_COMMANDS } = require('./registry');
 const NAME_COMMANDS = new Set(['show', 'find', 'usages', 'trace', 'tests', 'plan']);
 
 function parseSourceTarget(arg, params) {
-    if (params.range) return { ...params, file: params.file, range: params.range };
     const value = String(arg || '').trim();
+    // `source <file> --range=N-M`: the positional is the file (fix #433). A
+    // positional beside an explicit file stays a name, which the handler
+    // refuses with the range.
+    if (params.range) {
+        if (!params.file && value) return { ...params, file: value, range: params.range };
+        return { ...params, ...(value && { name: value }), range: params.range };
+    }
     const twoPart = value.match(/^(.+?)\s+(\d+(?:-\d+)?)$/);
     if (twoPart) return { ...params, file: params.file || twoPart[1], range: twoPart[2] };
     // A single-colon file:range target is a line request. Stable symbol
@@ -16,6 +22,15 @@ function parseSourceTarget(arg, params) {
     return { ...params, name: arg };
 }
 
+/** MCP and direct execute() params: with a range and no file, `name` is the
+ * file (`source` with name=<file>, range="N-M"; fix #433). */
+function sourceRangeTarget(params) {
+    if (params.range == null || (params.file && String(params.file).trim()) ||
+        typeof params.name !== 'string' || !params.name.trim()) return params;
+    const { name, ...rest } = params;
+    return { ...rest, file: name.trim() };
+}
+
 /** Build normalized execute() params from the shared CLI-style positional arg. */
 function buildPublicParams(command, arg, params = {}) {
     const clean = { ...params };
@@ -47,4 +62,4 @@ function isPublicCommand(command) {
     return CANONICAL_COMMANDS.includes(command);
 }
 
-module.exports = { buildPublicParams, isPublicCommand, parseSourceTarget };
+module.exports = { buildPublicParams, isPublicCommand, parseSourceTarget, sourceRangeTarget };

package/core/query-bodies.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const { langTraits, getParser, getLanguageAdapter, safeParse } = require('../languages');
+const { getUsageResult, storeUsageResult } = require('./cache');
+const { indexedContent, syntaxMode } = require('./source-memo');
+const localNameTrees = new WeakSet();
+
+/**
+ * Bodies whose declarations cannot bind a name outside their own scope.
+ * A block is damaged when an enclosing ERROR node or an enclosing block or
+ * callable with an error holds it. One native query lists those nodes in
+ * document order; a stack of the open ones stands for each block's
+ * ancestors (fix #435: every block walked its parent chain). In document
+ * order a node that starts before an open non-empty node ends lies inside it.
+ */
+function bodyRanges(tree, kinds) {
+    if (!tree) return null;
+    const ranges = [];
+    if (!tree.rootNode.hasError) {
+        // No node of an error-free tree has an error. A block's first and
+        // last tokens are its first and last characters (an error-free tree
+        // has no missing tokens), read from the parsed text when it is at
+        // hand instead of asking for two child nodes (fix #436).
+        const text = typeof tree.input === 'string' ? tree.input : null;
+        for (const body of tree.rootNode.descendantsOfType('block')) {
+            const start = body.startIndex, end = body.endIndex;
+            if (text !== null ? end - start >= 2 && text[start] === '{' && text[end - 1] === '}'
+                : body.firstChild?.type === '{' && body.lastChild?.type === '}') {
+                ranges.push([start + 1, end - 1]);
+            }
+        }
+        return ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+    }
+    const open = []; // [endIndex, damages descendants]
+    for (const node of tree.rootNode.descendantsOfType(['block', 'ERROR', ...kinds])) {
+        const start = node.startIndex, end = node.endIndex;
+        while (open.length && open[open.length - 1][0] <= start) open.pop();
+        const damaged = open.some(entry => entry[1]);
+        const hasError = node.hasError;
+        if (node.type === 'block' && !damaged && !hasError && node.firstChild?.type === '{' &&
+            node.lastChild?.type === '}') ranges.push([start + 1, end - 1]);
+        if (end > start) open.push([end, node.type === 'ERROR' || hasError]);
+    }
+    // Bindings in a block stay in that block. Retain nested ranges so a
+    // query-bearing function can still skip unrelated sibling scopes.
+    return ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+}
+
+function viewKey(owns) { return owns == null ? 'primary' : [...owns].sort((a, b) => a - b).join(','); }
+
+// Recovery remains visible at the same positions, in the same containers.
+// Never prune an erroneous callable or anything inside an ERROR node.
+function errorShape(tree) {
+    const errors = [], pending = [tree.rootNode];
+    while (pending.length) {
+        const node = pending.pop();
+        if (node.type === 'ERROR' || node.isMissing) {
+            const parents = [];
+            for (let parent = node.parent; parent; parent = parent.parent) {
+                parents.push([parent.type, parent.startIndex, parent.endIndex]);
+            }
+            errors.push([node.type, node.startIndex, node.endIndex, !!node.isMissing, parents]);
+        } else if (node.hasError) pending.push(...node.children);
+    }
+    return JSON.stringify(errors);
+}
+
+function readRanges(value, content) {
+    if (!Array.isArray(value) || !value.length) return null;
+    const views = new Map();
+    for (const record of value) {
+        if (!Array.isArray(record) || record.length !== 3 || typeof record[0] !== 'string' ||
+            views.has(record[0]) || !Array.isArray(record[1]) || typeof record[2] !== 'string') return null;
+        let previous = -1;
+        const ends = [];
+        for (const range of record[1]) {
+            if (!Array.isArray(range) || range.length !== 2 ||
+                !range.every(Number.isInteger) || range[0] <= previous || range[0] < 1 ||
+                range[1] < range[0] || range[1] >= content.length ||
+                content[range[0] - 1] !== '{' || content[range[1]] !== '}') return null;
+            while (ends.length && range[0] >= ends[ends.length - 1]) ends.pop();
+            if (ends.length && range[1] >= ends[ends.length - 1]) return null;
+            ends.push(range[1]);
+            previous = range[0];
+        }
+        views.set(record[0], { ranges: record[1], errors: record[2] });
+    }
+    return views.has('primary') ? views : null;
+}
+
+function blankBodies(source, ranges, name) {
+    const chunks = [];
+    let at = 0;
+    let occurrence = source.indexOf(name);
+    for (const [start, end] of ranges) {
+        if (start < at) continue;
+        while (occurrence >= 0 && occurrence < start) occurrence = source.indexOf(name, occurrence + name.length);
+        if (occurrence >= start && occurrence < end) continue;
+        const body = source.slice(start, end);
+        const newline = char => char === '\r' || char === '\n';
+        let first = 0, last = body.length - 2;
+        while (first < last && (newline(body[first]) || newline(body[first + 1]))) first++;
+        while (last > first + 1 && (newline(body[last]) || newline(body[last + 1]))) last--;
+        if (last <= first + 1) continue;
+        // All opted-in grammars have non-nesting block comments. One opaque
+        // token avoids parsing the unrelated body while preserving every
+        // UTF-16 offset and newline. Existing terminators stay inside it.
+        const comment = body.slice(first + 2, last).replace(/\*\//g, '* ');
+        chunks.push(source.slice(at, start), body.slice(0, first), '/*', comment, '*/', body.slice(last + 2));
+        at = end;
+    }
+    return chunks.length ? chunks.join('') + source.slice(at) : source;
+}
+
+/**
+ * Keep every declaration header and every body containing the queried text.
+ * The persisted facts are AST ranges, never type or ownership resolutions.
+ * These private trees never enter the index's complete parsed-tree caches.
+ */
+function localQueryTree(index, file, entry, language, name, content) {
+    const traits = langTraits(language);
+    if (!traits.closedQueryBodies?.length || !entry.hash || !index._usageResultCache ||
+        index.isProvenanceFactIndex || !indexedContent(index, file, entry, content)) return null;
+    const mode = syntaxMode('valueBodies', [language, traits.closedQueryBodies, entry.conditionalViews, entry.recoveryBlanks]);
+    const key = '\x01body-ranges';
+    const value = getUsageResult(index, file, key, mode);
+    const ranges = readRanges(value, content);
+    const persistent = index._persistentParsedTree?.(file, language);
+    const warm = index._opTreeCache?.has(file) || persistent?.fileHash === entry.hash;
+    const parser = getParser(language);
+    if (ranges && !warm) {
+        let complete = true;
+        const transform = (source, owns) => {
+            const view = ranges.get(viewKey(owns));
+            if (!view) { complete = false; return source; }
+            return blankBodies(source, view.ranges, name);
+        };
+        const tree = traits.queryBodyTree
+            ? traits.queryBodyTree(content, parser, entry, transform)
+            : safeParse(parser, transform(content, null));
+        const views = traits.queryBodyViews?.(tree) || [{ tree }];
+        if (complete && views.every(view => view.tree &&
+            errorShape(view.tree) === ranges.get(viewKey(view.owns))?.errors)) {
+            for (const view of views) localNameTrees.add(view.tree);
+            return tree;
+        }
+    }
+    const tree = index._getParsedTree(file, content, language) ||
+        getLanguageAdapter(language)?.queryTree?.(content, parser, entry) || safeParse(parser, content);
+    if (!ranges && tree) {
+        const views = traits.queryBodyViews?.(tree) || [{ tree }];
+        const kinds = new Set(traits.closedQueryBodies);
+        const records = views.map(view => [viewKey(view.owns), bodyRanges(view.tree, kinds), errorShape(view.tree)]);
+        if (records.every(record => record[1] !== null)) storeUsageResult(index, file, key, mode, records);
+    }
+    return tree;
+}
+
+module.exports = { localQueryTree, isLocalNameTree: tree => localNameTrees.has(tree), bodyRangesForTest: bodyRanges };