ucn 4.2.3 → 5.0.2

package/core/graph-build.js

@@ -7,7 +7,59 @@
 
 const path = require('path');
 const { resolveImport } = require('./imports');
-const { langTraits } = require('../languages');
+const { langTraits, getParser, safeParse } = require('../languages');
+
+function _javaPackageTypes(index) {
+    const packages = new Map();
+    for (const [filePath, fileEntry] of index.files) {
+        if (fileEntry.language !== 'java') continue;
+        for (const symbol of fileEntry.symbols || []) {
+            if (!symbol.namespace || !['class', 'interface', 'record', 'enum'].includes(symbol.type)) continue;
+            let names = packages.get(symbol.namespace);
+            if (!names) { names = new Map(); packages.set(symbol.namespace, names); }
+            let files = names.get(symbol.name);
+            if (!files) { files = new Set(); names.set(symbol.name, files); }
+            files.add(filePath);
+        }
+    }
+    return packages;
+}
+
+/** Collect same-package Java type references from AST roles that denote types. */
+function _javaSamePackageDependencies(index, filePath, fileEntry, packageTypes) {
+    const packageName = (fileEntry.symbols || []).find(symbol => symbol.namespace)?.namespace;
+    const candidates = packageTypes.get(packageName);
+    if (!packageName || !candidates || candidates.size === 0) return [];
+    let tree;
+    try {
+        tree = safeParse(getParser('java'), index._readFile(filePath));
+    } catch (_) {
+        return [];
+    }
+    const referenced = new Set();
+    const walk = node => {
+        if (node.type === 'type_identifier' && candidates.has(node.text)) {
+            referenced.add(node.text);
+        } else if (node.type === 'identifier' && candidates.has(node.text)) {
+            const parent = node.parent;
+            if (parent && ((parent.type === 'method_invocation' &&
+                parent.childForFieldName('object')?.id === node.id) ||
+                (parent.type === 'field_access' &&
+                parent.childForFieldName('object')?.id === node.id))) {
+                referenced.add(node.text);
+            }
+        }
+        for (let i = 0; i < node.namedChildCount; i++) walk(node.namedChild(i));
+    };
+    walk(tree.rootNode);
+    const out = new Set();
+    for (const name of referenced) {
+        for (const target of candidates.get(name) || []) {
+            if (target !== filePath) out.add(target);
+        }
+    }
+    return [...out];
+}
 
 /**
  * Build directory→files index for O(1) same-package lookups.
@@ -89,6 +141,33 @@ function _resolveJavaPackageImport(index, importModule, javaFileIndex, opts = {}
     return opts.all ? [] : null;
 }
 
+function _buildCSharpNamespaceIndex(index) {
+    const namespaces = new Map();
+    const add = (key, file) => {
+        if (!key) return;
+        if (!namespaces.has(key)) namespaces.set(key, []);
+        if (!namespaces.get(key).includes(file)) namespaces.get(key).push(file);
+    };
+    for (const [filePath, fileEntry] of index.files) {
+        if (fileEntry.language !== 'csharp') continue;
+        for (const symbol of fileEntry.symbols || []) {
+            if (!['class', 'interface', 'struct', 'record', 'enum'].includes(symbol.type)) {
+                continue;
+            }
+            add(symbol.namespace, filePath);
+            if (symbol.namespace) add(`${symbol.namespace}.${symbol.name}`, filePath);
+        }
+    }
+    return namespaces;
+}
+
+function _resolveCSharpUsing(index, importModule, namespaceIndex = null, opts = {}) {
+    const map = namespaceIndex || _buildCSharpNamespaceIndex(index);
+    const matches = map.get(importModule) || [];
+    if (opts.all) return [...matches];
+    return matches[0] || null;
+}
+
 /**
  * Build import/export relationship graphs
  */
@@ -100,6 +179,9 @@ function buildImportGraph(index) {
     const dirToGoFiles = new Map();
     // Pre-build filename→files map for Java import resolution (O(1) vs O(n) scan)
     const javaFileIndex = new Map();
+    const javaPackageTypes = _javaPackageTypes(index);
+    const csharpNamespaceIndex = _buildCSharpNamespaceIndex(index);
+    const csharpGlobalImports = new Set();
     for (const [fp, fe] of index.files) {
         if (langTraits(fe.language)?.packageScope === 'directory') {
             const dir = path.dirname(fp);
@@ -109,6 +191,10 @@ function buildImportGraph(index) {
             const name = path.basename(fp, '.java');
             if (!javaFileIndex.has(name)) javaFileIndex.set(name, []);
             javaFileIndex.get(name).push(fp);
+        } else if (fe.language === 'csharp') {
+            for (const moduleName of (fe.globalImports || [])) {
+                if (moduleName) csharpGlobalImports.add(moduleName);
+            }
         }
     }
 
@@ -123,7 +209,10 @@ function buildImportGraph(index) {
         // names is not evidence about THIS name's module).
         const moduleResolved = {};
 
-        for (const importModule of fileEntry.imports) {
+        const effectiveImports = fileEntry.language === 'csharp'
+            ? [...(fileEntry.imports || []), ...csharpGlobalImports]
+            : (fileEntry.imports || []);
+        for (const importModule of effectiveImports) {
             // Skip null modules (e.g., dynamic include! macros in Rust)
             if (!importModule) continue;
 
@@ -134,6 +223,7 @@ function buildImportGraph(index) {
 
             let resolved = resolveImport(importModule, filePath, {
                 aliases: index.config.aliases,
+                includePaths: index.config.includePaths,
                 language: fileEntry.language,
                 root: index.root
             });
@@ -156,18 +246,31 @@ function buildImportGraph(index) {
                 }
             }
 
+            let csharpFiles = null;
+            if (!resolved && fileEntry.language === 'csharp') {
+                const all = _resolveCSharpUsing(
+                    index, importModule, csharpNamespaceIndex, { all: true });
+                if (all.length > 0) {
+                    resolved = all[0];
+                    csharpFiles = all;
+                }
+            }
+
             if (resolved && index.files.has(resolved)) {
                 moduleResolved[importModule] = path.relative(index.root, resolved);
                 // For Go, a package import means all files in that directory are dependencies
                 // (Go packages span multiple files in the same directory)
-                const filesToLink = javaWildcardFiles ? [...javaWildcardFiles] : [resolved];
+                const filesToLink = javaWildcardFiles
+                    ? [...javaWildcardFiles]
+                    : csharpFiles ? [...csharpFiles] : [resolved];
                 if (langTraits(fileEntry.language)?.packageScope === 'directory') {
                     const pkgDir = path.dirname(resolved);
                     const dirFiles = dirToGoFiles.get(pkgDir) || [];
-                    const importerIsTest = filePath.endsWith('_test.go');
                     for (const fp of dirFiles) {
-                        if (fp !== resolved) {
-                            if (!importerIsTest && fp.endsWith('_test.go')) continue;
+                        if (fp !== resolved && fp !== filePath) {
+                            // Test files are compilation inputs, never part of
+                            // an importable Go package surface.
+                            if (fp.endsWith('_test.go')) continue;
                             filesToLink.push(fp);
                         }
                     }
@@ -183,6 +286,19 @@ function buildImportGraph(index) {
             }
         }
 
+        // Java same-package visibility needs no import declaration. Add only
+        // AST-proven type/static-qualifier references, not a package clique.
+        if (fileEntry.language === 'java') {
+            for (const linkedFile of _javaSamePackageDependencies(
+                index, filePath, fileEntry, javaPackageTypes)) {
+                importedFiles.add(linkedFile);
+                if (!index.exportGraph.has(linkedFile)) {
+                    index.exportGraph.set(linkedFile, new Set());
+                }
+                index.exportGraph.get(linkedFile).add(filePath);
+            }
+        }
+
         // From-import submodules (fix #224): `from . import jobs` binds
         // jobs.py as a plain NAME — the parser can't know (a from-import name
         // may be a symbol), the resolver can. Resolve the composed dotted
@@ -260,6 +376,38 @@ function buildInheritanceGraph(index) {
                         const alias = fileEntry.importAliases.find(a => a.local === parent);
                         if (alias && classNames.has(alias.original)) return alias.original;
                     }
+                    // Nominal languages commonly spell a project base with a
+                    // namespace/package qualifier (`detail::buffer<T>`,
+                    // `demo.Base`). The symbol table is keyed by the terminal
+                    // type name, so retaining the qualifier disconnects the
+                    // inheritance graph and can turn an inherited method call
+                    // into a false receiver mismatch. Strip it only when an
+                    // indexed type has the matching compiler owner; suffix
+                    // matching accommodates parsers which retain either the
+                    // full namespace or only its innermost component.
+                    if (langTraits(fileEntry.language)?.typeSystem === 'nominal' &&
+                        (parent.includes('::') || parent.includes('.'))) {
+                        const separator = parent.includes('::') ? '::' : '.';
+                        const pieces = parent.split(separator).filter(Boolean);
+                        const terminal = pieces.pop();
+                        const qualifier = pieces.join(separator);
+                        const typeKinds = new Set([
+                            'class', 'interface', 'struct', 'trait', 'record',
+                        ]);
+                        const matches = (index.symbols.get(terminal) || [])
+                            .filter(definition => {
+                                if (!typeKinds.has(definition.type)) return false;
+                                const owner = String(definition.namespace || '');
+                                return owner === qualifier ||
+                                    owner.endsWith(`${separator}${qualifier}`) ||
+                                    qualifier.endsWith(`${separator}${owner}`);
+                            });
+                        if (matches.length > 0 &&
+                            new Set(matches.map(definition =>
+                                definition.namespace || '')).size === 1) {
+                            return terminal;
+                        }
+                    }
                     // Qualified structural parent: `class CustomCommand(
                     // click.Command)`. The symbol table owns bare class names,
                     // so keeping `click.Command` makes the subclass invisible
@@ -347,4 +495,11 @@ function splitParentList(clause) {
         .filter(Boolean);
 }
 
-module.exports = { buildDirIndex, buildImportGraph, buildInheritanceGraph, splitParentList, _resolveJavaPackageImport };
+module.exports = {
+    buildDirIndex,
+    buildImportGraph,
+    buildInheritanceGraph,
+    splitParentList,
+    _resolveJavaPackageImport,
+    _resolveCSharpUsing,
+};

package/core/graph.js

@@ -79,12 +79,16 @@ function imports(index, filePath) {
             if (!resolvedPath && fileEntry.language === 'java' && !imp.module.startsWith('.')) {
                 resolvedPath = index._resolveJavaPackageImport(imp.module);
             }
+            if (!resolvedPath && fileEntry.language === 'csharp') {
+                resolvedPath = index._resolveCSharpUsing(imp.module);
+            }
 
             return {
                 module: imp.module,
                 names: imp.names,
                 type: imp.type,
                 resolved: resolvedPath ? path.relative(index.root, resolvedPath) : null,
+                indexed: !!(resolvedPath && index.files.has(resolvedPath)),
                 isExternal: !resolvedPath,
                 // A string-literal dynamic import (import('./x'), importlib.import_module("x"))
                 // is still mechanically dynamic even when the path resolves —
@@ -107,6 +111,35 @@ function imports(index, filePath) {
  */
 function symbolIsExported(symbol, fileEntry, exportedNames) {
     const modifiers = symbol.modifiers || [];
+    // Python's language-level public surface is convention based when the
+    // module does not declare __all__: top-level non-underscore names are
+    // public. Keep explicit __all__ authoritative when present.
+    if (fileEntry.language === 'python' &&
+        !(fileEntry.moduleAssignedNames || []).includes('__all__') &&
+        !symbol.className && !symbol.isMethod) {
+        return !!symbol.name && !symbol.name.startsWith('_');
+    }
+    if ((fileEntry.language === 'csharp' || fileEntry.language === 'java') &&
+        (symbol.className || symbol.enclosingType)) {
+        const typeKinds = new Set([
+            'class', 'struct', 'interface', 'record', 'enum', 'type',
+        ]);
+        const typeIsPublic = (name, namespace, seen = new Set()) => {
+            const identity = `${namespace || ''}\0${name}`;
+            if (seen.has(identity)) return false;
+            seen.add(identity);
+            return (fileEntry.symbols || []).some(candidate => {
+                if (!typeKinds.has(candidate.type) || candidate.name !== name ||
+                    (candidate.namespace || null) !== (namespace || null) ||
+                    !(candidate.modifiers || []).includes('public')) return false;
+                return !candidate.enclosingType || typeIsPublic(
+                    candidate.enclosingType, candidate.namespace,
+                    new Set(seen));
+            });
+        };
+        if (!typeIsPublic(symbol.className || symbol.enclosingType,
+            symbol.namespace)) return false;
+    }
     if (modifiers.includes('export') || modifiers.includes('public')) return true;
     if (modifiers.some(m => typeof m === 'string' && /^pub\b/.test(m))) return true;
     if (langTraits(fileEntry.language)?.exportVisibility === 'capitalization' &&
@@ -516,6 +549,8 @@ function fileExports(index, filePath, _visited) {
  */
 function api(index, filePath, options = {}) {
     const results = [];
+    let scopedFiles = 0;
+    let pythonImplicitFiles = 0;
 
     let fileIterator;
     if (filePath) {
@@ -540,95 +575,33 @@ function api(index, filePath, options = {}) {
         fileIterator = index.files.entries();
     }
 
-    for (const [, fileEntry] of fileIterator) {
+    for (const [absPath, fileEntry] of fileIterator) {
         if (!fileEntry) continue;
+        if (options.in &&
+            !index.matchesFilters(fileEntry.relativePath, { in: options.in })) {
+            continue;
+        }
 
         // Skip test files by default (test classes aren't part of public API)
         if (!options.includeTests && isTestFile(fileEntry.relativePath, fileEntry.language)) {
             continue;
         }
-
-        const exportedNames = new Set(fileEntry.exports);
-
-        for (const symbol of fileEntry.symbols) {
-            if (symbol.type === 'impl') continue;
-            if (symbolIsExported(symbol, fileEntry, exportedNames)) {
-                results.push({
-                    name: symbol.name,
-                    type: symbol.type,
-                    file: fileEntry.relativePath,
-                    startLine: symbol.startLine,
-                    endLine: symbol.endLine,
-                    ...(symbol.className && { className: symbol.className }),
-                    params: symbol.params,
-                    returnType: symbol.returnType,
-                    signature: formatExportSignature(index, symbol)
-                });
-            }
-        }
-
-        // Add variable exports (export const/let/var) not matched to symbols
-        if (fileEntry.exportDetails) {
-            const matchedNames = new Set(results.filter(r => r.file === fileEntry.relativePath).map(r => r.name));
-            for (const exp of fileEntry.exportDetails) {
-                if (exp.isVariable && !matchedNames.has(exp.name)) {
-                    const sig = `${exp.declKind} ${exp.name}${exp.typeAnnotation ? ': ' + exp.typeAnnotation : ''}`;
-                    results.push({
-                        name: exp.name,
-                        type: 'variable',
-                        file: fileEntry.relativePath,
-                        startLine: exp.line,
-                        endLine: exp.line,
-                        params: undefined,
-                        returnType: exp.typeAnnotation || null,
-                        signature: sig
-                    });
-                    matchedNames.add(exp.name);
-                }
-            }
-            // The fix #245 fileExports discipline, api side (fix #251 — the
-            // two commands diverged on the same file): consumers import the
-            // ALIAS, and clause-exported names with no indexed symbol
-            // (class/function expressions) are still API surface.
-            for (const exp of fileEntry.exportDetails) {
-                if (!exp || !exp.name || exp.module) continue;
-                if (exp.alias && exp.alias !== exp.name) {
-                    const entry = results.find(r =>
-                        r.file === fileEntry.relativePath && r.name === exp.name && !r.sourceName);
-                    if (entry) {
-                        entry.sourceName = exp.name;
-                        entry.name = exp.alias;
-                        if (entry.signature) {
-                            entry.signature = entry.signature.replace(exp.name, exp.alias);
-                        }
-                        matchedNames.add(exp.alias);
-                        continue;
-                    }
-                }
-                const shown = exp.alias || exp.name;
-                if (!matchedNames.has(shown) && !matchedNames.has(exp.name) &&
-                    exportedNames.has(exp.name)) {
-                    results.push({
-                        name: shown,
-                        ...(exp.alias && exp.alias !== exp.name && { sourceName: exp.name }),
-                        type: 'export',
-                        file: fileEntry.relativePath,
-                        startLine: exp.line || 1,
-                        endLine: exp.line || 1,
-                        params: undefined,
-                        returnType: null,
-                        signature: shown,
-                    });
-                    matchedNames.add(shown);
-                }
-            }
+        scopedFiles++;
+        if (fileEntry.language === 'python' && fileEntry.exports.length === 0) {
+            pythonImplicitFiles++;
         }
+        const exports = fileExports(index, absPath);
+        if (Array.isArray(exports)) results.push(...exports);
     }
 
     // Rule 11: (file, line) ordering regardless of parse order — file mode
     // used to emit symbols in extraction order (fix #251).
     results.sort((a, b) => codeUnitCompare(a.file, b.file) ||
         (a.startLine - b.startLine) || codeUnitCompare(a.name, b.name));
+    Object.defineProperty(results, 'apiInfo', {
+        value: { scopedFiles, pythonImplicitFiles },
+        enumerable: false, writable: true, configurable: true,
+    });
     return results;
 }
 
@@ -852,4 +825,7 @@ function circularDeps(index, options = {}) {
     }
 }
 
-module.exports = { imports, exporters, fileExports, api, graph, circularDeps };
+module.exports = {
+    imports, exporters, fileExports, api, graph, circularDeps,
+    symbolIsExported,
+};

package/core/imports.js

@@ -7,7 +7,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getParser, getLanguageModule } = require('../languages');
+const { getParser, getLanguageAdapter } = require('../languages');
 
 /**
  * Extract imports from file content using AST
@@ -20,7 +20,7 @@ function extractImports(content, language) {
     // Use JS language module for TS/TSX (same import syntax), but the actual language's parser
     const moduleLang = (language === 'typescript' || language === 'tsx') ? 'javascript' : language;
 
-    const langModule = getLanguageModule(moduleLang);
+    const langModule = getLanguageAdapter(moduleLang);
     if (langModule && typeof langModule.findImportsInCode === 'function') {
         try {
             const parser = getParser(language);
@@ -45,7 +45,7 @@ function extractExports(content, language) {
     // Use JS language module for TS/TSX (same export syntax), but the actual language's parser
     const moduleLang = (language === 'typescript' || language === 'tsx') ? 'javascript' : language;
 
-    const langModule = getLanguageModule(moduleLang);
+    const langModule = getLanguageAdapter(moduleLang);
     if (langModule && typeof langModule.findExportsInCode === 'function') {
         try {
             const parser = getParser(language);
@@ -180,8 +180,38 @@ function resolveImport(importPath, fromFile, config = {}) {
     }
 
     // Relative imports
+    const extensions = config.extensions || getExtensions(config.language);
     const resolved = path.resolve(fromDir, normalizedPath);
-    return resolveFilePath(resolved, config.extensions || getExtensions(config.language));
+    const direct = resolveFilePath(resolved, extensions);
+    if (direct) return direct;
+
+    // C/C++ quoted includes may be rooted at compiler -I/-iquote paths rather
+    // than the importing file. compile_commands.json is the authoritative
+    // build metadata when present; unresolved system includes remain external.
+    if (config.language === 'c' || config.language === 'cpp') {
+        const { includeDirectoriesForFile } = require('./compilation-database');
+        const includeName = normalizedPath.replace(/^\.\//, '');
+        const includeDirs = includeDirectoriesForFile(fromFile, config.root);
+        for (const configured of config.includePaths || []) {
+            if (typeof configured !== 'string' || !configured.trim()) continue;
+            includeDirs.push(path.isAbsolute(configured)
+                ? configured
+                : path.resolve(config.root || fromDir, configured));
+        }
+        // Header-only/source-distribution projects commonly omit a generated
+        // compile_commands.json but still use the conventional public
+        // `include/` root (`#include "fmt/format.h"`). These are project-owned
+        // files, not external packages. Try explicit compiler metadata first,
+        // then deterministic project roots; never search arbitrary parents.
+        if (config.root) {
+            includeDirs.push(config.root, path.join(config.root, 'include'));
+        }
+        for (const includeDir of [...new Set(includeDirs)]) {
+            const candidate = resolveFilePath(path.resolve(includeDir, includeName), extensions);
+            if (candidate) return candidate;
+        }
+    }
+    return null;
 }
 
 // Cache for Go module paths
@@ -484,8 +514,17 @@ function resolveRustImport(importPath, fromFile, projectRoot) {
         const cargo = findCargoRoot(fromDir);
         if (cargo && cargo.packageName && firstSeg === cargo.packageName) {
             const topDir = path.relative(cargo.root, fromFile).split(path.sep)[0];
+            const sourceRelative = path.relative(cargo.srcDir, fromFile);
+            const sourceHead = sourceRelative.split(path.sep)[0];
+            // A package's binaries are separate crates from its library even
+            // though both live below src/. `use package_name::Type` in
+            // src/main.rs or src/bin/** therefore names the lib target, not a
+            // child module of the binary. Treat these like examples/tests so
+            // the import graph can pin re-exported library types exactly.
+            const separateBinary = sourceRelative === 'main.rs' ||
+                sourceHead === 'bin';
             const externalTarget = topDir === 'tests' || topDir === 'benches' || topDir === 'examples' ||
-                !fromFile.startsWith(cargo.srcDir + path.sep);
+                separateBinary || !fromFile.startsWith(cargo.srcDir + path.sep);
             if (externalTarget) {
                 const restSegs = importPath.split('::').slice(1);
                 const resolved = restSegs.length > 0 ? resolveRustModulePath(cargo.srcDir, restSegs) : null;
@@ -593,7 +632,13 @@ function _findPackageJson(fromDir, stopDir) {
             try {
                 if (fs.existsSync(candidate)) {
                     const pkg = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-                    info = { dir: current, name: pkg.name, exports: pkg.exports, main: pkg.main };
+                    info = {
+                        dir: current,
+                        name: pkg.name,
+                        exports: pkg.exports,
+                        main: pkg.main,
+                        source: pkg.source,
+                    };
                 }
             } catch { /* unreadable or invalid JSON */ }
             _pkgCache.set(current, info);
@@ -666,6 +711,14 @@ function resolveSelfReference(importPath, fromDir, config) {
                 if (hit) return hit;
             }
         }
+        // Monorepo packages commonly export build artifacts that do not
+        // exist in a source checkout while declaring the development entry
+        // explicitly (`"source": "src/index.ts"`). For a package's own bare
+        // import, that source field is the authoritative local module.
+        if (subpath === '.' && typeof pkg.source === 'string') {
+            const source = resolveFilePath(path.resolve(pkg.dir, pkg.source), extensions);
+            if (source) return source;
+        }
         return null;
     }
     // No exports map: bare name -> main/index; subpath -> direct file
@@ -730,6 +783,12 @@ function getExtensions(language) {
             return ['.java'];
         case 'rust':
             return ['.rs'];
+        case 'c':
+            return ['.c', '.h'];
+        case 'cpp':
+            return ['.cc', '.cpp', '.cxx', '.c++', '.hpp', '.hh', '.hxx', '.h++', '.h'];
+        case 'csharp':
+            return ['.cs', '.csx'];
         default:
             return ['.js', '.ts'];
     }