ucn 5.5.0 → 5.5.2

package/core/type-denotation.js

@@ -45,6 +45,7 @@ const fs = require('fs');
 const path = require('path');
 const { langTraits } = require('../languages');
 const { findCargoRoot, findGoModule } = require('./imports');
+const { projectFact, projectHas, fileSymbolFact } = require('./provenance-overload');
 
 const TYPE_KINDS = new Set(['class', 'struct', 'interface', 'trait', 'enum', 'record', 'union']);
 
@@ -232,15 +233,20 @@ function projectNamespaces(index, language) {
     });
 }
 
+/** Does the project declare namespace/package `name`? A witness records
+ * the answer, never every file the inventory reads (fix #418). */
+function projectNamespaceDeclared(index, language, name) {
+    return projectHas(index, `namespaces:${language}`, name, live => projectNamespaces(live, language));
+}
+
 /** Is some leading dotted prefix of `qualified` (the full path excluded) a
  * namespace/package the project declares? `org.junit.Assert` is project
  * code when `org.junit` is a project package; nested types keep their
  * package prefix (`a.b.Outer.Inner`). */
 function hasProjectNamespacePrefix(index, language, qualified) {
-    const names = projectNamespaces(index, language);
     const segments = String(qualified).split('.');
     for (let i = segments.length - 1; i > 0; i--) {
-        if (names.has(segments.slice(0, i).join('.'))) return true;
+        if (projectNamespaceDeclared(index, language, segments.slice(0, i).join('.'))) return true;
     }
     return false;
 }
@@ -363,7 +369,10 @@ function externalTypeDenotation(index, filePath, name, qualifier, line, options
     // `unscoped`: the site's spelling of the name is unknown (the parser kept
     // only the last segment), so package/namespace scoping cannot apply.
     const unscoped = options.unscoped === true;
-    const key = `${filePath}\x00${name}\x00${qualifier || ''}\x00${scoped ?? ''}\x00${unscoped ? 1 : 0}`;
+    // Java/C# scoping reads the site's package or namespace (fix #433): a
+    // C# file with several namespace blocks decides a name per block.
+    const siteScope = !qualifier && !unscoped ? scopingSiteKey(index, filePath, line) : '';
+    const key = `${filePath}\x00${name}\x00${qualifier || ''}\x00${scoped ?? ''}\x00${unscoped ? 1 : 0}\x00${siteScope}`;
     return memoized(index, key, () => {
         const fileEntry = index.files.get(filePath);
         if (!fileEntry) return null;
@@ -465,7 +474,7 @@ function scopedTypeDenotation(index, fileEntry, filePath, name, line, scoping) {
         }
         if (implicitHas) return { original: name, via: `${implicit.module}.${name}` };
         const external = onDemand.filter(module => !hasProjectNamespacePrefix(index, language, `${module}.${name}`) &&
-            !projectNamespaces(index, language).has(module));
+            !projectNamespaceDeclared(index, language, module));
         if (external.length === 0) return null;
         return { original: name, via: `${external[0]}.*`,
             ...(!external.every(module => standardRooted(language, module)) && { certain: false }) };
@@ -485,10 +494,26 @@ function scopedTypeDenotation(index, fileEntry, filePath, name, line, scoping) {
     // `using static T` also brings T's nested types (already abstained above).
     const usings = new Set([...scope.namespaces, ...scope.statics]);
     if (projectTypes.some(definition => usings.has(definition.namespace))) return null;
-    const external = [...usings].filter(module => !csharpDeclaredNames(index).namespaces.has(module));
+    const external = [...usings].filter(module =>
+        !projectHas(index, 'cs-declared-namespaces', module, live => csharpDeclaredNames(live).namespaces));
     return { original: name, via: external.length > 0 ? `${external.sort()[0]}.${name}` : name };
 }
 
+/** What `scopedTypeDenotation` reads of the site: its package/namespace
+ * (`siteNamespaceOf`), constant for a file whose types share one namespace;
+ * '' for a language without type-name scoping. */
+function scopingSiteKey(index, filePath, line) {
+    const fileEntry = index.files.get(filePath);
+    if (!fileEntry || !langTraits(fileEntry.language)?.typeNameScoping) return '';
+    const namespaces = memoized(index, `\x01site-ns\x00${filePath}`, () => new Set(
+        fileSymbolFact(index, filePath, `file-type-namespaces\0${filePath}`, (symbols, live) => symbols
+            ? memoized(live, `\x01site-ns-facts\x00${filePath}`, () => symbols
+                .filter(symbol => TYPE_KINDS.has(symbol.type)).map(symbol => symbol.namespace || '')) : [])));
+    if (namespaces.size <= 1) return '\x01';
+    const namespace = siteNamespaceOf(fileEntry, line);
+    return namespace === undefined ? '\x02' : `\x03${namespace}`;
+}
+
 /** Could a project type named `name` be the type `fqn` names? Only a type
  * in a named package/namespace that prefixes it (nested types included). */
 function fqnMayName(index, language, name, fqn) {
@@ -551,10 +576,12 @@ function csharpResolveUsingName(index, written, enclosing) {
     const text = String(written || '').replace(/\s+/g, '').replace(/^global::/, '');
     if (!enclosing || !text) return text;
     const first = text.split('.')[0].replace(/<.*$/s, '');
-    const { namespaces, types } = csharpDeclaredNames(index);
     for (let parts = String(enclosing).split('.'); parts.length > 0; parts = parts.slice(0, -1)) {
         const candidate = `${parts.join('.')}.${first}`;
-        if (namespaces.has(candidate) || types.has(candidate)) return `${parts.join('.')}.${text}`;
+        if (projectHas(index, 'cs-declared-namespaces', candidate, live => csharpDeclaredNames(live).namespaces) ||
+            projectHas(index, 'cs-declared-types', candidate, live => csharpDeclaredNames(live).types)) {
+            return `${parts.join('.')}.${text}`;
+        }
     }
     return text;
 }
@@ -584,17 +611,36 @@ function csharpUsingTarget(text) {
     return String(text || '').replace(/<.*$/s, '');
 }
 
-function csharpAddDirective(scope, index, { module, names, static: isStatic, namespace }) {
-    const target = csharpUsingTarget(csharpResolveUsingName(index, module, namespace));
+function csharpAddDirective(scope, index, { module, names, static: isStatic, namespace, lexicalNamespace = namespace, rooted = false }) {
+    const syntax = csharpResolveUsingName(index, module,
+        rooted || String(module || '').startsWith('global::') ? '' : namespace);
+    const target = csharpUsingTarget(syntax);
     if (!target) return;
     const alias = (names || []).find(name => name && name !== '*');
     if (alias) {
+        const at = lexicalNamespace || '';
+        if (!scope.aliasDefinitions.has(alias)) scope.aliasDefinitions.set(alias, []);
+        scope.aliasDefinitions.get(alias).push({ namespace: at, syntax,
+            absolute: rooted || String(module || '').startsWith('global::') });
+        const previous = scope.aliasScopes?.get(alias);
+        // Project-file imports are added after source directives; that order
+        // cannot override a nearer namespace's alias.
+        if (scope.scoped && previous != null && previous.length > at.length) return;
+        if (scope.aliases.has(alias) && previous === at && scope.aliases.get(alias) !== target) {
+            scope.ambiguousAliases.add(alias);
+        } else if (previous !== at) scope.ambiguousAliases.delete(alias);
         scope.aliases.set(alias, target);
+        scope.aliasSyntax.set(alias, syntax);
         if (!scope.aliasScopes) scope.aliasScopes = new Map();
-        scope.aliasScopes.set(alias, namespace || '');
+        scope.aliasScopes.set(alias, at);
+    } else {
+        const values = isStatic ? scope.statics : scope.namespaces;
+        const origins = isStatic ? scope.staticScopes : scope.namespaceScopes;
+        values.add(target);
+        if (isStatic) scope.staticSyntax.set(target, syntax);
+        if (!origins.has(target)) origins.set(target, new Set());
+        origins.get(target).add(lexicalNamespace || '');
     }
-    else if (isStatic) scope.statics.add(target);
-    else scope.namespaces.add(target);
 }
 
 /**
@@ -602,29 +648,53 @@ function csharpAddDirective(scope, index, { module, names, static: isStatic, nam
  * directives (resolved from the namespace each is written in), `global
  * using` directives of every source file, and the <Using> items of the
  * project files above it (`csharpProjectFileUsings`).
- * Returns { namespaces: Set, statics: Set (type names), aliases: Map
- * (alias -> target), unreadable } - unreadable when a project file could not
+ * An optional namespace restricts local directives to that lexical chain;
+ * origins and original alias syntax support positive identity proofs.
+ * Returns namespaces/statics Sets, aliases and origin Maps, and unreadable.
+ * unreadable is true when a project file could not
  * be read (its items are unknown).
  */
-function csharpUsings(index, filePath) {
-    return memoized(index, `\x01cs-usings\x00${filePath}`, () => {
-        const scope = { namespaces: new Set(), statics: new Set(), aliases: new Map(), unreadable: false };
-        const globals = memoized(index, '\x01cs-global-usings', () => {
+function csharpUsings(index, filePath, namespace = null, siteNode = null, syntax = null) {
+    const scopes = syntax?.scopes || (siteNode ? require('../languages/csharp-scope').usingScopesOf(siteNode) : null);
+    const scopeKey = scopes?.map(scope => `${scope.startIndex}:${scope.endIndex}`).join(',') ?? '*';
+    return memoized(index, `\x01cs-usings\x00${filePath}\x00${namespace ?? '*'}\x00${scopeKey}`, () => {
+        const scope = { namespaces: new Set(), statics: new Set(), aliases: new Map(),
+            ambiguousAliases: new Set(), aliasSyntax: new Map(), aliasDefinitions: new Map(), scoped: namespace != null,
+            namespaceScopes: new Map(), staticScopes: new Map(), staticSyntax: new Map(), unreadable: false };
+        const globals = projectFact(index, 'cs-global-usings', live => memoized(live, '\x01cs-global-usings', () => {
             const out = [];
-            for (const [, entry] of index.files) {
+            for (const [, entry] of live.files) {
                 if (entry.language !== 'csharp') continue;
                 for (const detail of entry.importDetails || []) {
                     if (detail.global && detail.module) out.push(detail);
                 }
             }
             return out;
-        });
+        }));
         for (const detail of globals) csharpAddDirective(scope, index, detail);
         const fileEntry = index.files.get(filePath);
-        for (const detail of fileEntry?.importDetails || []) {
-            if (detail.type === 'using' && detail.module && !detail.global) {
-                csharpAddDirective(scope, index, detail);
-            }
+        let local = fileEntry?.importDetails || [];
+        if (syntax) local = syntax.directives;
+        else if (scopes) {
+            const content = index._readFile(filePath);
+            const language = require('../languages');
+            const parser = language.getParser(fileEntry.language);
+            const adapter = language.getLanguageAdapter(fileEntry.language);
+            const tree = (index.isProvenanceFactIndex && siteNode.tree) ||
+                (require('./query-bodies').isLocalNameTree(siteNode.tree) && siteNode.tree) ||
+                index._getParsedTree(filePath, content, fileEntry.language) ||
+                adapter.queryTree(content, parser, fileEntry);
+            local = adapter.queryUsingDirectives(tree);
+        }
+        for (const detail of local) {
+            if (detail.type !== 'using' || !detail.module || detail.global) continue;
+            if (scopes) {
+                const owner = detail.usingScopes.at(-1);
+                if (owner && !scopes.some(current => current.startIndex === owner.startIndex &&
+                    current.endIndex === owner.endIndex)) continue;
+                csharpAddDirective(scope, index, { ...detail, lexicalNamespace: owner?.namespace || '' });
+            } else if (namespace == null || !detail.namespace || namespace === detail.namespace ||
+                namespace.startsWith(detail.namespace + '.')) csharpAddDirective(scope, index, detail);
         }
         for (const item of csharpProjectFileUsings(index, filePath)) {
             if (item === null) { scope.unreadable = true; continue; }
@@ -643,26 +713,41 @@ function csharpUsings(index, filePath) {
  */
 function csharpExpandAliasTargets(scope) {
     const scopes = scope.aliasScopes;
-    if (!scopes || scope.aliases.size < 2) return;
+    if (!scopes) return;
     const encloses = (outer, inner) => outer !== inner && (outer === '' || inner.startsWith(`${outer}.`));
-    for (let pass = 0; pass < 4; pass++) {
-        let changed = false;
-        for (const [alias, target] of scope.aliases) {
-            const [head, ...rest] = String(target).split('.');
-            if (head === alias || !scope.aliases.has(head)) continue;
-            if (!encloses(scopes.get(head) ?? '', scopes.get(alias) ?? '')) continue;
-            scope.aliases.set(alias, [scope.aliases.get(head), ...rest].join('.'));
-            changed = true;
+    const expand = (definition, seen = new Set()) => {
+        if (definition.absolute) return definition.syntax;
+        if (seen.has(definition) || seen.size >= 16) return null;
+        const [head, ...rest] = definition.syntax.split('.');
+        const outer = (scope.aliasDefinitions.get(head) || []).filter(other =>
+            encloses(other.namespace, definition.namespace));
+        if (!outer.length) return definition.syntax;
+        const nearest = Math.max(...outer.map(other => other.namespace.length));
+        const next = new Set(seen); next.add(definition);
+        const targets = new Set(outer.filter(other => other.namespace.length === nearest)
+            .map(other => expand(other, next)));
+        if (targets.has(null) || targets.size !== 1) return null;
+        return [[...targets][0], ...rest].join('.');
+    };
+    for (const [alias, at] of scopes) {
+        const definitions = (scope.aliasDefinitions.get(alias) || []).filter(definition => definition.namespace === at);
+        const targets = new Set(definitions.map(definition => expand(definition)));
+        if (targets.has(null) || targets.size !== 1) {
+            scope.ambiguousAliases.add(alias);
+            continue;
         }
-        if (!changed) break;
+        const syntax = [...targets][0];
+        scope.aliasSyntax.set(alias, syntax);
+        scope.aliases.set(alias, csharpUsingTarget(syntax));
     }
 }
 
 /** The directory whose `.git` marks the repository holding `dir`, or null. */
 function gitTopOf(index, dir) {
     return memoized(index, `\x01git-top\x00${dir}`, () => {
+        const sourceFs = index.isProvenanceFactIndex ? index.provenanceFs : fs;
         for (let current = dir; ; current = path.dirname(current)) {
-            try { if (fs.existsSync(path.join(current, '.git'))) return current; } catch { /* keep walking */ }
+            try { if (sourceFs.existsSync(path.join(current, '.git'))) return current; } catch { /* keep walking */ }
             if (current === path.dirname(current)) return null;
         }
     });
@@ -679,6 +764,7 @@ function gitTopOf(index, dir) {
  * null marks a file that could not be read.
  */
 function csharpProjectFileUsings(index, filePath) {
+    const sourceFs = index.isProvenanceFactIndex ? index.provenanceFs : fs;
     const dirs = [];
     const root = path.resolve(index.root);
     let dir = path.dirname(filePath);
@@ -697,12 +783,12 @@ function csharpProjectFileUsings(index, filePath) {
     }
     return dirs.flatMap(current => memoized(index, `\x01cs-proj-usings\x00${current}`, () => {
         let names;
-        try { names = fs.readdirSync(current); } catch { return []; }
+        try { names = sourceFs.readdirSync(current); } catch { return []; }
         const out = [];
         for (const file of names.sort()) {
             if (!/\.csproj$|^Directory\.Build\.(props|targets)$/.test(file)) continue;
             let text;
-            try { text = fs.readFileSync(path.join(current, file), 'utf-8'); } catch { out.push(null); continue; }
+            try { text = sourceFs.readFileSync(path.join(current, file), 'utf-8'); } catch { out.push(null); continue; }
             for (const match of text.matchAll(/<Using\b([^>]*)>/g)) {
                 const include = /\bInclude\s*=\s*"([^"]+)"/.exec(match[1]);
                 if (!include) continue;
@@ -774,11 +860,14 @@ function rustScopedLine(index, filePath, line, name) {
     if (line == null) return null;
     const fileEntry = index.files.get(filePath);
     if (fileEntry?.language !== 'rust') return null;
-    const declares = (index.symbols.get(name) || []).some(definition => definition.file === filePath &&
-        (TYPE_KINDS.has(definition.type) || definition.type === 'type'));
-    const imports = (fileEntry.importBindings || []).some(binding =>
-        binding.name !== '*' && (binding.alias || binding.name) === name && binding.module);
-    return declares || imports ? line : null;
+    // Per file and name (fix #405: every `T::new()` site asked again).
+    const scoped = memoized(index, `scoped\x00${filePath}\x00${name}`, () => {
+        const declares = (index.symbols.get(name) || []).some(definition => definition.file === filePath &&
+            (TYPE_KINDS.has(definition.type) || definition.type === 'type'));
+        return declares || (fileEntry.importBindings || []).some(binding =>
+            binding.name !== '*' && (binding.alias || binding.name) === name && binding.module);
+    });
+    return scoped ? line : null;
 }
 
 /** Bindings visible at `line`: those of the innermost enclosing scope that
@@ -946,6 +1035,30 @@ function projectTypeNamed(index, name) {
     return (index.symbols.get(name) || []).some(definition => TYPE_KINDS.has(definition.type));
 }
 
+/**
+ * The type a call record writes and what it denotes in its file. A record
+ * never changes once its file's calls are read, so the answer is kept per
+ * record object while the index lives (fix #405b: orientation refines every
+ * definition of a name over the same records, and each refinement asked
+ * again per record).
+ */
+function siteDenotation(index, filePath, fileEntry, call) {
+    const memos = memoOf(index);
+    let memo = memos.get('\x01site');
+    if (!memo) memos.set('\x01site', memo = new WeakMap());
+    let site = memo.get(call);
+    if (site === undefined) {
+        const written = siteWrittenType(index, fileEntry, call);
+        site = {
+            written,
+            denotation: written ? externalTypeDenotation(index, filePath, written.name, written.qualifier,
+                call.line, { unscoped: written.unscoped === true }) : null,
+        };
+        memo.set(call, site);
+    }
+    return site;
+}
+
 /**
  * Verdict for a call site against candidate target definitions (the pinned
  * targets on the caller side, every same-name callable on the callee side).
@@ -961,10 +1074,7 @@ function externalTypeGate(index, filePath, fileEntry, call, targetsOrThunk) {
     // every project type with the method set satisfies; the existing
     // package-qualified physics routes it (possible dispatch).
     if (fileEntry.language === 'go') return null;
-    const written = siteWrittenType(index, fileEntry, call);
-    if (!written) return null;
-    const denotation = externalTypeDenotation(index, filePath, written.name, written.qualifier, call.line,
-        { unscoped: written.unscoped === true });
+    const { written, denotation } = siteDenotation(index, filePath, fileEntry, call);
     if (!denotation) return null;
     const { original, via } = denotation;
     // Only a real collision needs the gate: without a project type of that
@@ -1143,6 +1253,7 @@ function stripExternalReceiverType(call, via) {
 }
 
 module.exports = {
+    memoizedDerivation: memoized,
     externalTypeDenotation,
     externalReceiverVerdict,
     externalProducerVia,