ucn 5.5.1 → 5.5.2

package/core/decorator-binding.js

@@ -177,12 +177,16 @@ function returnedDecorator(fnNode, family) {
 /**
  * Resolve a decorator's head name to one project callable definition, or null.
  */
-function projectDecoratorDef(index, def, head, rest) {
+function projectDecoratorDef(index, def, head, rest, implementation = false) {
     const { _nameBindingReaches, _moduleAttributeBindingReaches } = require('./callers');
     const target = rest ? rest.slice(1) : head;
     if (rest && rest.includes('.', 1)) return null;
+    // `@overload` stubs declare signatures of the implementation beside
+    // them; the implementation decides what a call returns (fix #434).
     const candidates = (index.symbols.get(target) || []).filter(candidate =>
-        !candidate.className && /function|method/.test(candidate.type || 'function'));
+        !candidate.className && /function|method/.test(candidate.type || 'function') &&
+        !(implementation && (candidate.decorators || []).some(name =>
+            /^(typing\.)?overload$/.test(String(typeof name === 'string' ? name : name?.name || '')))));
     const reaching = candidates.filter(candidate => {
         const targets = new Set([candidate.file]);
         if (!rest) {
@@ -257,4 +261,134 @@ function nameBindingDecorators(index, def, memo = new Map()) {
     return unproven;
 }
 
-module.exports = { nameBindingDecorators };
+// A Python `if` condition testing the parameter against None: true for
+// `p is None`, false for `p is not None`, null for anything else.
+function noneTest(condition, p) {
+    if (condition?.type !== 'comparison_operator' || condition.namedChildCount !== 2) return null;
+    const [left, right] = condition.namedChildren;
+    if (left.type !== 'identifier' || left.text !== p || right.type !== 'none') return null;
+    const operators = condition.children.filter(child => !child.isNamed).map(child => child.type);
+    if (operators.length === 1 && operators[0] === 'is') return true;
+    if (operators.length === 2 && operators[0] === 'is' && operators[1] === 'not') return false;
+    return null;
+}
+
+/**
+ * The return statements of a Python function body that run when the
+ * parameter `p` is None (`pIsNone`) or is a class (fix #434): branches of
+ * `if p is None` / `if p is not None` the value rules out are skipped;
+ * nested definitions, lambdas and classes run elsewhere.
+ */
+function pythonReturnsUnder(block, p, pIsNone, out = []) {
+    for (const statement of namedChildrenOf(block)) {
+        if (statement.type === 'return_statement') { out.push(statement); continue; }
+        if (/^(function_definition|class_definition|decorated_definition)$/.test(statement.type)) continue;
+        if (statement.type === 'if_statement') {
+            const test = noneTest(statement.childForFieldName('condition'), p);
+            if (test !== null) {
+                if (test === pIsNone) pythonReturnsUnder(statement.childForFieldName('consequence'), p, pIsNone, out);
+                else {
+                    for (const alternative of namedChildrenOf(statement).filter(child =>
+                        child.type === 'else_clause' || child.type === 'elif_clause')) {
+                        if (alternative.type === 'elif_clause') return null;
+                        pythonReturnsUnder(alternative.childForFieldName('body'), p, pIsNone, out);
+                    }
+                }
+                continue;
+            }
+        }
+        let invalid = false;
+        traverseTree(statement, node => {
+            if (invalid) return false;
+            if (/^(function_definition|class_definition|lambda)$/.test(node.type)) return false;
+            if (node.type === 'return_statement') out.push(node);
+            if (node.type === 'yield') invalid = true;
+            return true;
+        });
+        if (invalid) return null;
+    }
+    return out;
+}
+
+/** Nested function definitions of a body, by name (not inside other defs). */
+function nestedDefinitions(fnNode) {
+    const nested = new Map();
+    const body = fnNode.childForFieldName('body');
+    traverseTree(body, node => {
+        if (sameNode(node, body)) return true;
+        const definition = node.type === 'decorated_definition' ? node.childForFieldName('definition') : node;
+        if (definition?.type === 'function_definition') {
+            const name = definition.childForFieldName('name');
+            if (name && node.type === 'function_definition') nested.set(name.text, definition);
+            return false;
+        }
+        return !/^(class_definition|lambda)$/.test(node.type);
+    });
+    return nested;
+}
+
+/**
+ * Python: decorator `fnNode` applied to a class returns that class (fix
+ * #434): every return reachable when its first parameter holds the class
+ * returns the parameter, or passes it first to a nested function that
+ * does. `pIsNone` evaluates the factory form (`@d(..)` with the class
+ * parameter left at its None default): every reachable return then gives
+ * a decorator that returns its argument.
+ */
+function pythonReturnsItsClass(fnNode, scope, depth = 0, pIsNone = false) {
+    if (!fnNode || depth > 4) return false;
+    const p = firstParamName(fnNode, 'python');
+    const body = fnNode.childForFieldName('body');
+    if (!p || !body) return false;
+    const nested = new Map([...scope, ...nestedDefinitions(fnNode)]);
+    const returns = pythonReturnsUnder(body, p, pIsNone);
+    if (!returns || returns.length === 0) return false;
+    return returns.every(statement => {
+        const value = statement.namedChild(0);
+        if (pIsNone) {
+            const decorator = value?.type === 'identifier' ? nested.get(value.text) : null;
+            return !!decorator && pythonReturnsItsClass(decorator, nested, depth + 1);
+        }
+        if (value?.type === 'identifier') return value.text === p;
+        if (value?.type !== 'call') return false;
+        const callee = value.childForFieldName('function');
+        const first = namedChildrenOf(value.childForFieldName('arguments'))[0];
+        const inner = callee?.type === 'identifier' ? nested.get(callee.text) : null;
+        return !!inner && first?.type === 'identifier' && first.text === p &&
+            pythonReturnsItsClass(inner, nested, depth + 1);
+    });
+}
+
+/**
+ * Whether a project class decorator returns the class it decorates (fix
+ * #434): `@register` / `@rich_repr` / `@rich_repr(angular=True)` keep the
+ * class (and its synthesized initializer) in place.
+ */
+function classPreservingDecorator(index, classDef, text) {
+    const fileEntry = index.files.get(classDef.file);
+    if (fileEntry?.language !== 'python') return false;
+    const call = text.indexOf('(');
+    const expr = (call >= 0 ? text.slice(0, call) : text).trim();
+    if (!/^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)?$/.test(expr)) return false;
+    const dot = expr.indexOf('.');
+    const head = dot < 0 ? expr : expr.slice(0, dot);
+    const rest = dot < 0 ? '' : expr.slice(dot);
+    const target = projectDecoratorDef(index, classDef, head, rest, true);
+    if (!target) return false;
+    const tree = treeOf(index, target.file);
+    const fnNode = tree ? functionNodeAt(tree, target.nameLine || target.startLine, target.name) : null;
+    if (!fnNode) return false;
+    if (call < 0) return pythonReturnsItsClass(fnNode, new Map());
+    // The factory form: the class parameter is left at its None default
+    // when no positional argument is passed.
+    const args = text.slice(call + 1, text.lastIndexOf(')')).trim();
+    const positional = args.length > 0 && args.split(',').some(arg => !/^\s*[A-Za-z_]\w*\s*=/.test(arg));
+    const firstParam = namedChildrenOf(fnNode.childForFieldName('parameters'))[0];
+    if (!positional && firstParam?.type === 'default_parameter' &&
+        firstParam.childForFieldName('value')?.type === 'none') {
+        return pythonReturnsItsClass(fnNode, new Map(), 0, true);
+    }
+    return pythonReturnsItsClass(returnedDecorator(fnNode, 'python'), new Map());
+}
+
+module.exports = { nameBindingDecorators, classPreservingDecorator };

package/core/enum-reference-syntax.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const { langTraits } = require('../languages');
+const cache = require('./cache');
+const { indexedContent, parseViewParts, syntaxMode } = require('./source-memo');
+const { TypeReferenceResolver } = require('./type-references');
+const { classDefsNamed, findDeclaringClass } = require('./class-identity');
+
+function validScope(value) {
+    return value && typeof value.namespace === 'string' &&
+        Number.isInteger(value.startIndex) && Number.isInteger(value.endIndex) &&
+        value.startIndex >= 0 && value.endIndex >= value.startIndex;
+}
+
+function validContext(value) {
+    return value == null || Array.isArray(value.scopes) && value.scopes.every(validScope) &&
+        Array.isArray(value.directives) && value.directives.every(detail => detail &&
+            typeof detail.type === 'string' && typeof detail.module === 'string' &&
+            Array.isArray(detail.names) && detail.names.every(name => typeof name === 'string') &&
+            (detail.namespace == null || typeof detail.namespace === 'string') &&
+            ['static', 'global', 'rooted'].every(key => detail[key] == null || typeof detail[key] === 'boolean') &&
+            Array.isArray(detail.usingScopes) && detail.usingScopes.every(validScope));
+}
+
+/** Persist syntax only; every owner and member verdict is recomputed. */
+class EnumReferenceSyntax {
+    constructor(resolver) { this.resolver = resolver; this.states = new Map(); }
+
+    collecting(file) { return this.states.get(file)?.valid === true; }
+
+    capture(file, fact) {
+        const state = this.states.get(file);
+        if (!state?.valid) return;
+        if (!fact) state.valid = false;
+        else state.facts.push(fact);
+    }
+
+    read(file, entry, language, rows, content) {
+        const r = this.resolver, index = r.index;
+        if (file === r.def.file || r.owner?.def?.type !== 'enum' ||
+            !langTraits(language)?.staticEnumReferenceSyntax || !entry.hash ||
+            !index._usageResultCache || index.isProvenanceFactIndex ||
+            !indexedContent(index, file, entry, content)) return null;
+        const mode = syntaxMode('enumSyntax', [...parseViewParts(entry, language), rows]);
+        this.states.set(file, { valid: true, facts: [], mode });
+        const value = cache.getUsageResult(index, file, r.name, mode);
+        if (!Array.isArray(value) || value.length !== 3 || value[0] !== 2 ||
+            !Array.isArray(value[1]) || !Array.isArray(value[2])) return null;
+        const lines = new Map(), wanted = new Set(rows);
+        for (const record of value[1]) {
+            if (!Array.isArray(record) || record.length !== 4 || !wanted.has(record[0]) ||
+                lines.has(record[0]) || !Number.isInteger(record[1]) || record[1] < 0 ||
+                typeof record[2] !== 'boolean' || record[3] !== 0) return null;
+            lines.set(record[0], { edits: [], reviews: [], skips: 0, skipColumns: [],
+                text: record[2], tokens: record[1], macroBody: false });
+        }
+        if (lines.size !== rows.length) return null;
+        const counts = new Map(), references = [];
+        for (const fact of value[2]) {
+            if (!fact || !wanted.has(fact.line) || !Number.isInteger(fact.column) || fact.column < 0 ||
+                !Number.isInteger(fact.at) || fact.at < 0 || content.slice(fact.at, fact.at + r.name.length) !== r.name ||
+                !['member', 'type', 'opaque'].includes(fact.kind) || typeof fact.accessKind !== 'string' ||
+                fact.kind !== 'opaque' && (typeof fact.receiver !== 'string' || !fact.receiver) ||
+                fact.kind === 'opaque' && (!['macro', 'template'].includes(fact.sourceRole) ||
+                    fact.receiver != null || fact.context != null || fact.owner != null) ||
+                !validContext(fact.context) || fact.owner != null &&
+                (typeof fact.owner.name !== 'string' || !Number.isInteger(fact.owner.startLine) ||
+                    !Number.isInteger(fact.owner.endLine) || fact.owner.startLine < 1 ||
+                    fact.owner.endLine < fact.owner.startLine)) return null;
+            if (fact.kind !== 'opaque' && langTraits(language).enumReferenceContext && fact.context == null) return null;
+            counts.set(fact.line, (counts.get(fact.line) || 0) + 1);
+        }
+        for (const [line, slot] of lines) if ((counts.get(line) || 0) !== slot.tokens) return null;
+        for (const fact of value[2]) {
+            const lookup = fact.kind === 'opaque' ? null : this.ownerOf(file, language, fact);
+            if (fact.kind !== 'opaque' && !lookup) return null;
+            const verdict = fact.kind === 'opaque'
+                ? { verdict: 'unknown', reason: 'value-binding-unresolved' } : r.memberAt(lookup.owner);
+            const slot = lines.get(fact.line);
+            if (verdict.verdict === 'yes') slot.edits.push(fact.column);
+            else if (verdict.verdict === 'unknown') slot.reviews.push({ column: fact.column, reason: verdict.reason });
+            else { slot.skips++; slot.skipColumns.push(fact.column); }
+            references.push({ file: entry.relativePath, absoluteFile: file,
+                line: fact.line, column: fact.column, expression: index.getLineContent(file, fact.line).trim(),
+                ...(fact.kind === 'member' && { receiver: fact.receiver }), accessKind: fact.accessKind,
+                verdict: verdict.verdict, reason: verdict.reason });
+        }
+        r.references.push(...references);
+        return lines;
+    }
+
+    ownerOf(file, language, fact) {
+        const r = this.resolver, index = r.index;
+        if (fact.kind === 'member' && langTraits(language).bareCallReachesMethods) {
+            let enclosing = null;
+            if (fact.owner) {
+                const entries = classDefsNamed(index, fact.owner.name).entries.filter(e =>
+                    e.def.file === file && e.def.startLine <= fact.owner.startLine &&
+                    e.def.endLine >= fact.owner.endLine);
+                if (new Set(entries.map(e => e.key)).size !== 1) return null;
+                enclosing = { name: entries[0].def.name, key: entries[0].key, def: entries[0].def };
+            } else if (index.findEnclosingFunction(file, fact.line, true)?.className) return null;
+            const members = (index.symbols.get(fact.receiver) || []).filter(d => d.className);
+            if (enclosing && findDeclaringClass(index, enclosing, members)) return { owner: null };
+        }
+        if ((index.symbols.get(fact.receiver) || []).some(d => d.type === 'type')) return null;
+        const matches = [];
+        for (const entry of classDefsNamed(index, fact.receiver).entries) {
+            // Same-file declarations also need the native lexical scope relation.
+            if (entry.def.file === file) return null;
+            const sub = new TypeReferenceResolver(index, entry.def, fact.receiver);
+            sub.siteFile = file;
+            if (fact.context) sub.siteSyntax = { file, line: fact.line, arity: 0, context: fact.context };
+            const verdict = sub.resolveName(file, fact.line, fact.receiver);
+            if (verdict.verdict === 'unknown') return { owner: null };
+            if (verdict.verdict === 'yes') matches.push(entry);
+        }
+        if (new Set(matches.map(e => e.key)).size !== 1) return { owner: null };
+        return { owner: { name: matches[0].def.name, key: matches[0].key, def: matches[0].def } };
+    }
+
+    remember(file, lines) {
+        const state = this.states.get(file);
+        if (!state?.valid) return;
+        const counts = new Map();
+        for (const fact of state.facts) counts.set(fact.line, (counts.get(fact.line) || 0) + 1);
+        if ([...lines].some(([line, slot]) => slot.macroBody || slot.stringAnnotation ||
+            slot.tokens !== (counts.get(line) || 0) || slot.tokens === 0 && !slot.text)) return;
+        const value = [2, [...lines].map(([line, slot]) => [line, slot.tokens, slot.text, 0]), state.facts];
+        cache.storeUsageResult(this.resolver.index, file, this.resolver.name, state.mode, value);
+    }
+}
+
+module.exports = { EnumReferenceSyntax };

package/core/execute.js

@@ -16,6 +16,7 @@ const { addTestExclusions, pickBestDefinition, parseSymbolHandle, looksLikeHandl
 const { cleanHtmlScriptTags, detectLanguage } = require('./parser');
 const { renderExpandItem } = require('./expand-cache');
 const { CANONICAL_COMMANDS } = require('./registry');
+const { sourceRangeTarget } = require('./public-command');
 const { isAccessorDefinition } = require('./accessors');
 const { describeError } = require('./errors');
 
@@ -1547,7 +1548,7 @@ const HANDLERS = {
             p.name.includes('/') || p.name.includes('\\') ||
             /\.(js|ts|py|go|java|rs)$/.test(p.name));
         if (!testsTargetIsFile) applyClassMethodSyntax(p);
-        if (testsTargetIsHandle && p.line) {
+        if (!testsTargetIsFile && p.line) {
             const line = Number(p.line);
             const resolvedFile = p.file ? index.resolveFilePathForQuery(p.file) : null;
             const pinned = (index.symbols.get(p.name) || []).filter(d =>
@@ -1589,6 +1590,9 @@ const HANDLERS = {
         const result = index.tests(p.name, {
             callsOnly: p.callsOnly || false,
             className: p.className,
+            // A line pin names one definition, including the file/line
+            // parameters passed by a composed command such as show.
+            ...(!testsTargetIsFile && p.line && testsResolution?.def && { definition: testsResolution.def }),
             // Bare ambiguous names use the same deterministic definition as
             // the rest of the semantic surface. The warning below discloses
             // that choice and gives the caller a stable file= escape hatch.
@@ -1681,6 +1685,7 @@ const HANDLERS = {
             if (result.excludedDecorated != null) sliced.excludedDecorated = result.excludedDecorated;
             if (result.excludedExternalContract != null) sliced.excludedExternalContract = result.excludedExternalContract;
             if (result.excludedRuntimeContract != null) sliced.excludedRuntimeContract = result.excludedRuntimeContract;
+            if (result.excludedConstructors != null) sliced.excludedConstructors = result.excludedConstructors;
             if (result.excludedDynamicDispatch != null) sliced.excludedDynamicDispatch = result.excludedDynamicDispatch;
             if (result.pythonImplicitExportFiles != null) sliced.pythonImplicitExportFiles = result.pythonImplicitExportFiles;
             if (result.computedDispatch != null) sliced.computedDispatch = result.computedDispatch;
@@ -2515,9 +2520,18 @@ function execute(index, command, params = {}) {
     // logged params object; a frozen object silently no-oped the
     // normalizers and returned wrong not-found answers).
     params = { ...params };
+    if (command === 'source') params = sourceRangeTarget(params);
     // Listing completeness belongs to execution, including direct API calls.
     if (params.lines) params.all = true;
+    // Composed commands share one source snapshot and its derived facts.
+    // Child operations still balance their scopes; the outer command owns
+    // the lifetime so summary/relationships/source do not repeat reads.
+    let operation = false;
     try {
+        if (typeof index?._beginOp === 'function' && typeof index?._endOp === 'function') {
+            index._beginOp();
+            operation = true;
+        }
         if (PUBLIC_COMMAND_SET.has(command)) {
             const validationError = validatePublicParams(command, params);
             if (validationError) return { ok: false, error: validationError };
@@ -2564,6 +2578,8 @@ function execute(index, command, params = {}) {
         // A deliberate refusal keeps its message; an exception inside the
         // engine is marked internal on every surface (fix #394).
         return { ok: false, ...describeError(e) };
+    } finally {
+        if (operation) index._endOp();
     }
 }
 

package/core/external-macros.js

@@ -115,7 +115,7 @@ function leadsWithProjectMacro(body, perName) {
 // `catch (...) { }` / `try`: statement fragments are read by the probe
 // even though they hold braces.
 function mayBeStatementFragment(body) {
-    return /^(?:try|catch|if)\b/.test(body.trim());
+    return /^(?:try|catch|if|while|for|switch)\b/.test(body.trim());
 }
 
 /**
@@ -166,24 +166,53 @@ function projectMacroDictionary(index, files) {
         if (!readingMemo.has(key)) readingMemo.set(key, compute());
         return readingMemo.get(key);
     };
+    // An object-like body naming another project macro that reads as
+    // decoration reads as the rest of it (fix #427).
+    const { withoutDecorationMacros } = require('../languages/c-family');
+    const objectReading = new Map();
+    const objectReadingOf = name => {
+        if (objectReading.has(name)) return objectReading.get(name);
+        objectReading.set(name, null); // in progress
+        const slot = perName.get(name);
+        let reading = null;
+        if (slot && slot.objects.size > 0 && slot.functions.size === 0 && !slot.objects.has(null)) {
+            const bodies = [...slot.objects].sort(codeUnitCompare).map(body => withoutDecorationMacros(body,
+                word => word !== name && perName.has(word) && objectReadingOf(word) === 'decoration'));
+            if (bodies.every(body => !body || maySpecify(body) || mayBeStatementFragment(body)) &&
+                !bodies.some(body => leadsWithProjectMacro(body, perName))) {
+                reading = read(`o\0${bodies.join('\u0001')}`, () => objectMacroReading(parser, bodies));
+            }
+        }
+        objectReading.set(name, reading);
+        return reading;
+    };
     const objectBodies = [];
     const functionMacros = [];
+    // Function-like macros whose every expansion ends in a function head
+    // (fix #427): an invocation followed by a body defines the function the
+    // expansion names (`DEF_PRIMITIVE(name) { .. }`).
+    const functionHeads = [];
+    const { endsFunctionHead } = require('../languages/c-family');
     for (const name of [...perName.keys()].sort(codeUnitCompare)) {
         const slot = perName.get(name);
         // Every definition of the name is one kind; object bodies are short.
         if (slot.objects.size > 0 && slot.functions.size > 0) continue;
         if (slot.objects.size > 0) {
             if (slot.objects.has(null)) continue;
-            const bodies = [...slot.objects].sort(codeUnitCompare);
-            if (!bodies.every(body => !body || maySpecify(body) || mayBeStatementFragment(body))) continue;
-            if (bodies.some(body => leadsWithProjectMacro(body, perName))) continue;
-            const reading = read(`o\0${bodies.join('\u0001')}`, () => objectMacroReading(parser, bodies));
-            if (reading === 'decoration' || reading === 'statement' || reading === 'if') objectBodies.push([name, bodies]);
+            const reading = objectReadingOf(name);
+            if (reading === 'decoration' || reading === 'statement' || reading === 'if') {
+                objectBodies.push([name, [...slot.objects].sort(codeUnitCompare).map(body => withoutDecorationMacros(body,
+                    word => word !== name && perName.has(word) && objectReadingOf(word) === 'decoration'))]);
+            }
             continue;
         }
         const templates = [...slot.functions.values()]
             .sort((a, b) => codeUnitCompare(JSON.stringify(a), JSON.stringify(b)));
         if (new Set(templates.map(template => template.params.length)).size !== 1) continue;
+        if (templates.every(template => template.body && endsFunctionHead(template.body)) &&
+            !templates.some(template => leadsWithProjectMacro(template.body, perName))) {
+            functionHeads.push([name, templates]);
+        }
         // Only an attribute or return-type macro (its expansion reads as
         // specifiers or a type) can explain a misread declaration; statement
         // macros such as test assertions read as calls.
@@ -197,8 +226,8 @@ function projectMacroDictionary(index, files) {
         if (reading === 'decoration' || reading === 'type') functionMacros.push([name, templates]);
     }
     const byLanguage = {};
-    if (objectBodies.length > 0 || functionMacros.length > 0) {
-        const entries = { objectBodies, functionMacros };
+    if (objectBodies.length > 0 || functionMacros.length > 0 || functionHeads.length > 0) {
+        const entries = { objectBodies, functionMacros, functionHeads };
         byLanguage.c = entries;
         byLanguage.cpp = entries;
     }
@@ -222,6 +251,7 @@ function contextFor(dictionary, language, excluded = null) {
             key: `${dictionary.key}-${[...excluded].sort(codeUnitCompare).join(',')}`,
             objectBodies: new Map(entry.objectBodies.filter(keep)),
             functionMacros: new Map(entry.functionMacros.filter(keep)),
+            functionHeads: new Map((entry.functionHeads || []).filter(keep)),
             consulted: new Set(),
         };
     }
@@ -233,7 +263,8 @@ function contextFor(dictionary, language, excluded = null) {
     }
     let maps = byLanguage.get(language);
     if (!maps) {
-        maps = { objectBodies: new Map(entry.objectBodies), functionMacros: new Map(entry.functionMacros) };
+        maps = { objectBodies: new Map(entry.objectBodies), functionMacros: new Map(entry.functionMacros),
+            functionHeads: new Map(entry.functionHeads || []) };
         byLanguage.set(language, maps);
     }
     return { key: dictionary.key, ...maps, consulted: new Set() };
@@ -245,8 +276,9 @@ function keyOfNames(dictionary, language, names) {
     const entry = dictionary?.byLanguage?.[language];
     const objects = new Map(entry?.objectBodies || []);
     const functions = new Map(entry?.functionMacros || []);
+    const heads = new Map(entry?.functionHeads || []);
     const parts = [...new Set(names)].sort(codeUnitCompare)
-        .map(name => [name, objects.get(name) || null, functions.get(name) || null]);
+        .map(name => [name, objects.get(name) || null, functions.get(name) || null, heads.get(name) || null]);
     return crypto.createHash('sha1').update(JSON.stringify(parts)).digest('base64url');
 }
 

package/core/go-packages.js

@@ -0,0 +1,171 @@
+/**
+ * core/go-packages.js - Go package identity and build configurations.
+ *
+ * A Go package is the set of files of one directory that share a package
+ * clause: `package x` files (test files included, for `go test`) and the
+ * external test package `package x_test` of the same directory are two
+ * packages, and a non-test file never sees a `_test.go` declaration. One
+ * package-level identifier denotes one entity in a build configuration; files
+ * that declare it under different `//go:build` constraints (or GOOS/GOARCH
+ * file-name suffixes) are configuration alternatives of one item (fix #425).
+ */
+
+'use strict';
+
+const path = require('path');
+
+const GO_OS = new Set(['aix', 'android', 'darwin', 'dragonfly', 'freebsd', 'hurd', 'illumos', 'ios', 'js',
+    'linux', 'nacl', 'netbsd', 'openbsd', 'plan9', 'solaris', 'wasip1', 'windows', 'zos']);
+const GO_ARCH = new Set(['386', 'amd64', 'amd64p32', 'arm', 'arm64', 'arm64be', 'armbe', 'loong64', 'mips',
+    'mips64', 'mips64le', 'mips64p32', 'mips64p32le', 'mipsle', 'ppc', 'ppc64', 'ppc64le', 'riscv', 'riscv64',
+    's390', 's390x', 'sparc', 'sparc64', 'wasm']);
+
+// Package-level type kinds a method set belongs to.
+const GO_TYPE_KINDS = new Set(['struct', 'interface', 'type', 'class', 'enum']);
+
+/**
+ * The build configurations a Go file belongs to (fix #399): its
+ * `//go:build` expression plus the GOOS/GOARCH its file name implies
+ * (`x_linux.go`, `x_windows_amd64_test.go`); '' when every build compiles it.
+ */
+function goFileConstraint(index, file) {
+    const memo = index._opMemo?.('goFileConstraint', () => new Map());
+    const cached = memo?.get(file);
+    if (cached !== undefined) return cached;
+    const constraint = goFileConstraintUncached(index, file);
+    memo?.set(file, constraint);
+    return constraint;
+}
+
+function goFileConstraintUncached(index, file) {
+    const tag = index.files.get(file)?.buildConstraint || '';
+    const parts = path.basename(file, '.go').replace(/_test$/, '').split('_');
+    let implied = '';
+    if (parts.length >= 3 && GO_OS.has(parts[parts.length - 2]) && GO_ARCH.has(parts[parts.length - 1])) {
+        implied = `${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+    } else if (parts.length >= 2 && (GO_OS.has(parts[parts.length - 1]) || GO_ARCH.has(parts[parts.length - 1]))) {
+        implied = parts[parts.length - 1];
+    }
+    return tag || implied ? `${tag}|${implied}` : '';
+}
+
+const isTestFile = file => file.endsWith('_test.go');
+
+/**
+ * Does a package-level declaration of `declFile` belong to the package a
+ * bare name in `siteFile` is resolved in? Same directory, same package
+ * clause (`x` and `x_test` are two packages), and a `_test.go` declaration
+ * only for a test file. A file whose clause is unknown keeps the directory
+ * rule.
+ */
+function goSamePackage(index, siteFile, declFile) {
+    if (!siteFile || !declFile) return false;
+    if (siteFile === declFile) return true;
+    if (path.dirname(siteFile) !== path.dirname(declFile)) return false;
+    const site = index.files.get(siteFile)?.packageName;
+    const decl = index.files.get(declFile)?.packageName;
+    if (site && decl && site !== decl) return false;
+    return isTestFile(siteFile) || !isTestFile(declFile);
+}
+
+/**
+ * The directories of the project packages `siteFile` dot-imports
+ * (`import . "p"`), whose exported package-level names its file block holds.
+ */
+function goDotImportDirs(index, siteFile) {
+    const memo = index._opMemo?.('goDotImportDirs', () => new Map());
+    if (memo?.has(siteFile)) return memo.get(siteFile);
+    const entry = index.files.get(siteFile);
+    let dirs = null;
+    for (const detail of entry?.importDetails || []) {
+        if (detail.type !== 'dot-import' || !detail.module) continue;
+        const rel = entry.moduleResolved?.[detail.module];
+        if (!rel) continue;
+        const abs = path.isAbsolute(rel) ? rel : path.join(index.root, rel);
+        (dirs || (dirs = new Set())).add(path.dirname(abs));
+    }
+    memo?.set(siteFile, dirs);
+    return dirs;
+}
+
+/**
+ * Does a bare name in `siteFile` reach the package-level declaration `def`?
+ * Its own package's declarations (goSamePackage), or an exported non-test
+ * declaration of a package the file dot-imports (Go spec, Import
+ * declarations: the external test package `x_test` that dot-imports `x` sees
+ * x's exported names unqualified).
+ */
+function goBareNameReaches(index, siteFile, def) {
+    if (!def?.file) return false;
+    if (goSamePackage(index, siteFile, def.file)) return true;
+    if (isTestFile(def.file) || !/^\p{Lu}/u.test(def.name || '')) return false;
+    const dirs = goDotImportDirs(index, siteFile);
+    if (!dirs || !dirs.has(path.dirname(def.file))) return false;
+    // The imported package is the directory's non-test package.
+    return !String(index.files.get(def.file)?.packageName || '').endsWith('_test');
+}
+
+/**
+ * Are two declarations configuration alternatives of one Go item? Files of
+ * one package that both declare a package-level name compile together only
+ * in a program that does not build (the name would be redeclared), so two
+ * such declarations under different file constraints are one item in two
+ * build configurations: same name, same receiver type, one package, one
+ * test side, and at least one constrained file.
+ */
+function goBuildAlternatives(index, a, b) {
+    if (!a || !b || a === b || a.file === b.file || a.name !== b.name) return false;
+    if (path.dirname(a.file) !== path.dirname(b.file)) return false;
+    if (isTestFile(a.file) !== isTestFile(b.file)) return false;
+    const pa = index.files.get(a.file)?.packageName;
+    const pb = index.files.get(b.file)?.packageName;
+    if (!pa || pa !== pb) return false;
+    if (a.lexicalScopeStartLine != null || b.lexicalScopeStartLine != null) return false;
+    if (a.isNested || b.isNested) return false;
+    const ownerOf = d => String(d.receiver || d.className || '').replace(/^\*/, '').replace(/\[.*$/, '') || null;
+    if (ownerOf(a) !== ownerOf(b)) return false;
+    // A function and a type of one name are not alternatives of one item.
+    if (GO_TYPE_KINDS.has(a.type) !== GO_TYPE_KINDS.has(b.type)) return false;
+    const ca = goFileConstraint(index, a.file);
+    const cb = goFileConstraint(index, b.file);
+    return ca !== cb && !!(ca || cb);
+}
+
+/**
+ * The alternatives of one item a site in `siteFile` reaches: a site in a
+ * file whose constraint is one alternative's own compiles only with that
+ * alternative (the site's file and that alternative's file build together,
+ * so no other alternative does); any other site reaches each of them.
+ */
+function goAlternativesAt(index, siteFile, alternatives) {
+    if (!siteFile || alternatives.length < 2) return alternatives;
+    const own = alternatives.filter(d => d.file === siteFile);
+    if (own.length > 0) return own;
+    const site = goFileConstraint(index, siteFile);
+    if (!site) return alternatives;
+    const same = alternatives.filter(d => goFileConstraint(index, d.file) === site);
+    return same.length > 0 ? same : alternatives;
+}
+
+/**
+ * Package-level types named `name` the package of `siteFile` declares
+ * (fix #425): what a receiver no local binds (`T.M`, `(*T).M`) denotes when
+ * the package declares a type of that name.
+ */
+function goPackageTypes(index, siteFile, name) {
+    if (!name) return [];
+    return (index.symbols.get(name) || []).filter(d => d.file && GO_TYPE_KINDS.has(d.type) &&
+        d.lexicalScopeStartLine == null && !d.className && !d.receiver &&
+        index.files.get(d.file)?.language === 'go' && goSamePackage(index, siteFile, d.file));
+}
+
+module.exports = {
+    goFileConstraint,
+    goSamePackage,
+    goDotImportDirs,
+    goBareNameReaches,
+    goBuildAlternatives,
+    goAlternativesAt,
+    goPackageTypes,
+    GO_TYPE_KINDS,
+};

package/core/graph-build.js

@@ -604,6 +604,8 @@ function _applyGoImportNames(index, filePath, fileEntry, moduleResolved, dirToGo
  * Build inheritance relationship graphs
  */
 function buildInheritanceGraph(index) {
+    index._implicitConversionOwners = null;
+    index._constructionAliases = null;
     index.extendsGraph.clear();
     index.extendedByGraph.clear();