ucn 4.2.3 → 5.0.2

package/core/brief.js

@@ -18,6 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { detectLanguage } = require('../languages');
 const { formatSymbolHandle } = require('./shared');
+const { computeAstComplexity } = require('./ast-analysis');
 
 // ============================================================================
 // Side-effect signal sets (per-language, conservative)
@@ -114,6 +115,10 @@ function brief(index, name, options = {}) {
             ...(def.paramsStructured && { paramsStructured: def.paramsStructured }),
             ...(def.paramTypes && { paramTypes: def.paramTypes }),
             ...(def.returnType && { returnType: def.returnType }),
+            ...(def.fieldType && { fieldType: def.fieldType }),
+            ...(def.memberType && { memberType: def.memberType }),
+            ...(def.generics && { generics: def.generics }),
+            ...(def.functionLike !== undefined && { functionLike: def.functionLike }),
             ...(def.modifiers && def.modifiers.length && { modifiers: def.modifiers }),
             ...(def.decorators && def.decorators.length && { decorators: def.decorators }),
             ...(def.docstring && { docstring: firstSentence(def.docstring) }),
@@ -131,7 +136,8 @@ function brief(index, name, options = {}) {
         }
 
         // For non-callable types (class/struct/interface/type), most fields don't apply
-        if (['class', 'struct', 'interface', 'type', 'enum'].includes(def.type)) {
+        if (['class', 'struct', 'interface', 'type', 'enum', 'record',
+            'trait', 'namespace'].includes(def.type)) {
             return {
                 symbol,
                 kind: 'type',
@@ -141,12 +147,25 @@ function brief(index, name, options = {}) {
             };
         }
 
+        const isData = def.type === 'field' || def.type === 'state' ||
+            def.memberType === 'field' || def.memberType === 'property' ||
+            (def.type === 'macro' && def.functionLike === false);
+        if (isData) {
+            return {
+                symbol,
+                kind: 'data',
+                lineCount: (def.endLine || def.startLine) - def.startLine + 1,
+                ...(gitInfo && { git: gitInfo }),
+            };
+        }
+
         // For callable symbols, scan the body
         const filePath = path.isAbsolute(def.file) ? def.file : path.join(index.root, def.file);
         let bodyText = '';
+        let fileContent = '';
         try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const lines = content.split('\n');
+            fileContent = fs.readFileSync(filePath, 'utf-8');
+            const lines = fileContent.split('\n');
             const start = Math.max(0, (def.startLine || 1) - 1);
             const end = Math.min(lines.length, def.endLine || def.startLine || 1);
             bodyText = lines.slice(start, end).join('\n');
@@ -167,7 +186,10 @@ function brief(index, name, options = {}) {
         const fileImports = collectImportNames(fileEntry);
 
         const sideEffects = classifySideEffects(bodyText, language, fileImports);
-        const complexity = computeComplexity(bodyText, language);
+        const complexity = computeAstComplexity(fileContent, language, {
+            startLine: def.startLine || 1,
+            endLine: def.endLine || def.startLine || 1,
+        });
 
         return {
             symbol,
@@ -307,59 +329,6 @@ function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-/**
- * Compute complexity metrics from a function body.
- * Cheap, AST-free counts on tokenized source.
- */
-function computeComplexity(bodyText, language) {
-    const lines = bodyText.split('\n');
-    const lineCount = lines.length;
-
-    // Branch count: count keywords that introduce a new branching path.
-    // We deliberately ignore final `else` (it's just the alternate of an `if`).
-    const branchPatterns = [
-        /\bif\s*\(/g,        // JS/TS/Java/Rust/Go/C-like
-        /\bif\s+/g,          // Python (if x:)
-        /\belif\b/g,         // Python
-        /\belse\s+if\b/g,    // JS/Java/etc.
-        /\bcase\b/g,         // switch case
-        /\bwhen\b/g,         // Rust match arms (and Kotlin/Scala but we don't support those)
-        /\bfor\s*\(/g,       // C-like for
-        /\bfor\s+\w/g,       // Python for x in
-        /\bwhile\s*\(/g,     // C-like while
-        /\bwhile\s+/g,       // Python while x:
-        /\?[^?]/g,           // ternary (rough)
-        /\bcatch\s*\(/g,     // catch
-        /\bexcept\b/g,       // Python except
-    ];
-    let branches = 0;
-    for (const re of branchPatterns) branches += (bodyText.match(re) || []).length;
-
-    // maxDepth: indent-based proxy. Fast, language-agnostic, off-by-one safe.
-    let maxDepth = 0;
-    let firstNonBlankIndent = -1;
-    for (const line of lines) {
-        if (!line.trim()) continue;
-        const m = line.match(/^(\s*)/);
-        const spaces = m ? expandIndent(m[1]) : 0;
-        if (firstNonBlankIndent === -1) firstNonBlankIndent = spaces;
-        // depth = (current - first) / unit; we don't know "unit", so just track
-        // raw delta and divide by 2 (conservative — most code is 2 or 4 space indented).
-        const rawDepth = Math.max(0, spaces - firstNonBlankIndent);
-        if (rawDepth > maxDepth) maxDepth = rawDepth;
-    }
-    // Translate raw spaces to depth levels (assume 2-space indent baseline)
-    const depth = Math.round(maxDepth / 2);
-
-    return { branches, maxDepth: depth, lineCount };
-}
-
-function expandIndent(s) {
-    let n = 0;
-    for (const c of s) n += (c === '\t') ? 4 : 1;
-    return n;
-}
-
 /**
  * Lazy classifier: side-effect tags for an arbitrary symbol record.
  * Used by callee output (`context`, `about`) to surface [fs]/[net]/[proc] tags
@@ -402,6 +371,6 @@ module.exports = {
     sideEffectsFor,
     // exposed for tests
     classifySideEffects,
-    computeComplexity,
+    computeComplexity: computeAstComplexity,
     firstSentence,
 };

package/core/build-worker.js

@@ -12,78 +12,13 @@ const { workerData } = require('worker_threads');
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { detectLanguage, getParser, getLanguageModule, langTraits } = require('../languages');
-const { parse } = require('./parser');
-const { extractImports, extractExports } = require('./imports');
+const { detectLanguage, getParser, getLanguageAdapter } = require('../languages');
+const { validateFileIR } = require('./ir');
+const { createFileEntryFromIR, populateFileEntryFromIR } = require('./index-ir');
 
 const { files, rootDir, existingHashes, signal, workerIndex, port } = workerData;
 const signalArray = new Int32Array(signal);
 
-function addSymbol(fileEntry, item, type) {
-    const symbol = {
-        name: item.name,
-        type,
-        file: fileEntry.path,
-        relativePath: fileEntry.relativePath,
-        startLine: item.startLine,
-        endLine: item.endLine,
-        params: item.params,
-        paramsStructured: item.paramsStructured,
-        returnType: item.returnType,
-        modifiers: item.modifiers,
-        docstring: item.docstring,
-        bindingId: `${fileEntry.relativePath}:${type}:${item.startLine}`,
-    };
-    // Field set MUST mirror project.js addSymbol exactly — a worker-side drop
-    // silently strips the field from every parallel-built index (>500 files).
-    // The cache.test.js / perf-optimizations.test.js indexSnapshot guards
-    // compare full symbol shapes, but only for shapes present in their
-    // fixtures — keep this list in sync by hand when addSymbol grows.
-    if (item.paramTypes) symbol.paramTypes = item.paramTypes;
-    if (item.returnedFunctionResult) symbol.returnedFunctionResult = item.returnedFunctionResult;
-    if (item.isFunctionVariable) symbol.isFunctionVariable = true;
-    if (item.isAsync) symbol.isAsync = true;
-    if (item.isGenerator) symbol.isGenerator = true;
-    if (item.generics) symbol.generics = item.generics;
-    if (item.extends) symbol.extends = item.extends;
-    if (item.implements) symbol.implements = item.implements;
-    if (item.indent !== undefined) symbol.indent = item.indent;
-    if (item.isNested) symbol.isNested = item.isNested;
-    if (item.enclosingType) symbol.enclosingType = item.enclosingType;
-    if (item.isMethod) symbol.isMethod = item.isMethod;
-    if (item.receiver) symbol.receiver = item.receiver;
-    if (item.className) symbol.className = item.className;
-    if (item.memberType) symbol.memberType = item.memberType;
-    if (item.fieldType) symbol.fieldType = item.fieldType;
-    if (item.aliasOf) symbol.aliasOf = item.aliasOf;
-    if (item.derefTarget) symbol.derefTarget = item.derefTarget;
-    if (item.decorators && item.decorators.length > 0) symbol.decorators = item.decorators;
-    if (item.decoratorsWithArgs && item.decoratorsWithArgs.length > 0) symbol.decoratorsWithArgs = item.decoratorsWithArgs;
-    if (item.annotationsWithArgs && item.annotationsWithArgs.length > 0) symbol.annotationsWithArgs = item.annotationsWithArgs;
-    if (item.attributesWithArgs && item.attributesWithArgs.length > 0) symbol.attributesWithArgs = item.attributesWithArgs;
-    if (item.nameLine) symbol.nameLine = item.nameLine;
-    if (item.traitImpl) symbol.traitImpl = true;
-    if (item.traitName) symbol.traitName = item.traitName;
-    if (item.isSignature) symbol.isSignature = true;
-    if (item.memberAssigned) symbol.memberAssigned = true;
-    if (item.bodyScopedName) symbol.bodyScopedName = true;
-    if (item.registryMember) symbol.registryMember = true;
-    if (item.registryContainer) symbol.registryContainer = item.registryContainer;
-
-    fileEntry.symbols.push(symbol);
-    // Property-assignment defs declare no lexical name (fix #269) — kept in
-    // lockstep with project.js addSymbol (the parallel≡sequential guard).
-    // Named function expressions bind only inside their own body.
-    if (!item.memberAssigned && !item.bodyScopedName) {
-        fileEntry.bindings.push({
-            id: symbol.bindingId,
-            name: symbol.name,
-            type: symbol.type,
-            startLine: symbol.startLine,
-        });
-    }
-}
-
 function processFile(filePath) {
     const stat = fs.statSync(filePath);
     const existing = existingHashes[filePath];
@@ -101,25 +36,17 @@ function processFile(filePath) {
         return { filePath, skipped: true, mtimeUpdate: stat.mtimeMs, sizeUpdate: stat.size };
     }
 
-    const language = detectLanguage(filePath);
+    const language = detectLanguage(filePath, rootDir);
     if (!language) return { filePath, skipped: true };
 
-    // Parse content — safeParse cache ensures tree is shared across
-    // parse()/extractImports()/extractExports()/findCallsInCode() (1 parse per file)
-    const parsed = parse(content, language);
-    const { imports, dynamicCount, importAliases } = extractImports(content, language);
-    const { exports } = extractExports(content, language);
-
-    // Extract calls in the same pass (eliminates buildCalleeIndex re-parsing)
-    let calls = null;
-    const langModule = getLanguageModule(language);
-    if (langModule.findCallsInCode) {
-        const parser = getParser(language);
-        const callOpts = {};
-        if (langTraits(language)?.hasReceiverPackageCalls) {
-            callOpts.imports = imports.flatMap(i => i.names || []);
-        }
-        calls = langModule.findCallsInCode(content, parser, callOpts);
+    // One adapter analysis produces the complete, validated file IR consumed
+    // by both worker and sequential builds.
+    const adapter = getLanguageAdapter(language);
+    const parser = getParser(language);
+    const ir = adapter.analyze(content, parser, filePath);
+    const irFailures = validateFileIR(ir);
+    if (irFailures.length > 0) {
+        throw new Error(`Invalid ${language} IR: ${irFailures.join('; ')}`);
     }
 
     // Detect bundled/minified files (same logic as indexFile in project.js)
@@ -150,69 +77,23 @@ function processFile(filePath) {
 
     const relativePath = path.relative(rootDir, filePath);
 
-    // Build fileEntry (mirrors indexFile)
-    const fileEntry = {
-        path: filePath,
+    const fileEntry = createFileEntryFromIR({
+        ir,
+        filePath,
         relativePath,
-        language,
-        lines: lineCount,
         hash,
         mtime: stat.mtimeMs,
         size: stat.size,
-        imports: imports.map(i => i.module),
-        importNames: imports.flatMap(i => i.names || []),
-        // Paired name↔module bindings (fix #209) — mirrors indexFile; was
-        // missing here, so parallel-built indexes (>500 files) silently lost
-        // the name-level scope/ownership discipline (found during fix #217).
-        importBindings: imports.flatMap(i => (i.names || [])
-            .filter(n => n && n !== '*' && n !== '_' && n !== '.')
-            .map(n => {
-                // Rename pairing (fix #269) — lockstep with project.js.
-                const rn = (i.renames || []).find(r => r.original === n);
-                return {
-                    name: n,
-                    module: i.module,
-                    ...(rn && { alias: rn.local }),
-                    ...(i.defaultLike && { defaultLike: true }),
-                };
-            })),
-        exports: exports.map(e => e.name),
-        exportDetails: exports,
-        symbols: [],
-        bindings: [],
-        dynamicImports: dynamicCount || 0,
-    };
-    if (parsed.parseRecovery) fileEntry.parseRecovery = true;
-    if (importAliases) fileEntry.importAliases = importAliases;
-    if (parsed.moduleAssignedNames) fileEntry.moduleAssignedNames = parsed.moduleAssignedNames;
-    if (isBundled) fileEntry.isBundled = true;
-    if (isGenerated) fileEntry.isGenerated = true;
-
-    // Build symbols (mirrors indexFile)
-    for (const fn of parsed.functions) {
-        if (fn.receiver && !fn.className) {
-            fn.className = fn.receiver.replace(/^\*/, '');
-        }
-        addSymbol(fileEntry, fn, fn.isConstructor ? 'constructor' : 'function');
-    }
-
-    for (const cls of parsed.classes) {
-        addSymbol(fileEntry, cls, cls.type || 'class');
-        if (cls.members) {
-            for (const m of cls.members) {
-                addSymbol(fileEntry, { ...m, className: cls.name, ...(cls.traitName && { traitImpl: true, traitName: cls.traitName }) }, m.memberType || 'method');
-            }
-        }
-    }
-
-    for (const state of parsed.stateObjects) {
-        addSymbol(fileEntry, state, 'state');
-    }
+        lineCount,
+        isBundled,
+        isGenerated,
+    });
+    populateFileEntryFromIR(fileEntry, ir);
 
     return {
         filePath,
         fileEntry,
-        calls,
+        calls: ir.calls,
         callsMtime: stat.mtimeMs,
         callsHash: hash,
         hadExisting: !!existing,