codedeep-mcp 0.1.0

package/dist/indexer/extractor.js

@@ -0,0 +1,354 @@
+import { createHash } from 'node:crypto';
+import { log } from '../logger.js';
+import { NON_CALLABLE_KINDS, classNameFromFqn } from '../types.js';
+import { extractCpp } from './languages/cpp.js';
+import { extractCSharp } from './languages/csharp.js';
+import { extractDart } from './languages/dart.js';
+import { extractGo } from './languages/go.js';
+import { extractJava } from './languages/java.js';
+import { extractKotlin } from './languages/kotlin.js';
+import { extractObjc } from './languages/objc.js';
+import { extractPHP } from './languages/php.js';
+import { extractRuby } from './languages/ruby.js';
+import { extractRust } from './languages/rust.js';
+import { extractSwift } from './languages/swift.js';
+import { extractPython } from './languages/python.js';
+import { extractTypeScript } from './languages/typescript.js';
+const DEFAULT_BARE_CALLEE_TYPES = new Set(['identifier']);
+// Selector for bare decorator forms (`@foo`, `@dataclass`). For `@foo()` and
+// `@ns.dec()` the child is `call_expression`/`call` and the call selector
+// emits the ref via walkCalls (the latter as a member ref); bare `@foo.bar`
+// has a `member_expression`/`attribute` child and stays skipped — it is an
+// access, not a call. Shared by TS and Python — both use `identifier` as
+// the node type for plain names.
+export function bareDecoratorIdentifier(node) {
+    const child = node.firstNamedChild;
+    return child?.type === 'identifier' ? child : null;
+}
+export function extractSymbols(tree, content, fileInfo) {
+    switch (fileInfo.language) {
+        case 'typescript':
+        case 'tsx':
+        case 'javascript':
+            return extractTypeScript(tree, content, fileInfo);
+        case 'python':
+            return extractPython(tree, content, fileInfo);
+        case 'java':
+            return extractJava(tree, content, fileInfo);
+        case 'go':
+            return extractGo(tree, content, fileInfo);
+        case 'rust':
+            return extractRust(tree, content, fileInfo);
+        case 'swift':
+            return extractSwift(tree, content, fileInfo);
+        case 'kotlin':
+            return extractKotlin(tree, content, fileInfo);
+        case 'dart':
+            return extractDart(tree, content, fileInfo);
+        case 'csharp':
+            return extractCSharp(tree, content, fileInfo);
+        case 'php':
+            return extractPHP(tree, content, fileInfo);
+        case 'ruby':
+            return extractRuby(tree, content, fileInfo);
+        case 'cpp':
+        // C reuses the C++ extractor wholesale: tree-sitter-c and tree-sitter-cpp
+        // produce byte-identical ASTs for the C subset, and every C++-specific
+        // branch (namespaces, templates, `::`, `new`, operators, `extern "C"`,
+        // access specifiers) is simply inert on C. `.c` uses the dedicated C
+        // grammar (parser.ts) so K&R + C++-keyword-identifier code parses cleanly;
+        // symbols still carry language 'c' (makeCppSymbol reads fileInfo.language).
+        case 'c':
+            return extractCpp(tree, content, fileInfo);
+        case 'objc':
+            // Objective-C is a C SUPERSET: extractObjc reuses cpp.ts's C-subset machinery
+            // (delegating every non-OO node to handleMember at file scope) and implements
+            // the OO surface (@interface/@implementation/@protocol/@property/methods/message
+            // sends) itself. A fresh extractor — NOT folded into extractCpp like C (a subset).
+            return extractObjc(tree, content, fileInfo);
+        default:
+            log.warn(`extractSymbols: unsupported language "${fileInfo.language}"`);
+            return { symbols: [], references: [], imports: [] };
+    }
+}
+export function symbolId(file, name, kind, signature, qualifier = '') {
+    const tail = qualifier ? `\0${qualifier}` : '';
+    return createHash('sha1')
+        .update(`${file}\0${name}\0${kind}\0${signature}${tail}`)
+        .digest('hex')
+        .slice(0, 16);
+}
+const SIGNATURE_WS = /\s+/g;
+// Stored/displayed signatures are capped at this length; the symbol id
+// hashes the FULL normalized signature. Capping the hash input too would
+// collide overloads that differ only past the cap (rxjava's 10 `just`
+// overloads produced 5 ids), silently merging their reference graphs.
+export const SIGNATURE_DISPLAY_CAP = 120;
+// Shared by every language module. The output feeds symbolId hashing, so
+// all languages must normalize identically — never fork a local copy.
+// Returns the FULL normalized signature; the language symbol constructors
+// apply SIGNATURE_DISPLAY_CAP to the stored copy only.
+export function normalizeSignature(raw) {
+    return raw.trim().replace(SIGNATURE_WS, ' ');
+}
+// First non-empty line of a `/** */`, `/* */`, or `//` comment, cleaned.
+// Shared by the TS and Java doc extractors (Python docs are docstrings).
+export function commentDocLine(text) {
+    if (text.startsWith('/**')) {
+        const inner = text.slice(3, text.endsWith('*/') ? -2 : undefined);
+        for (const line of inner.split('\n')) {
+            const cleaned = line.replace(/^\s*\*?\s?/, '').trimEnd();
+            if (cleaned)
+                return cleaned;
+        }
+        return null;
+    }
+    if (text.startsWith('/*')) {
+        const inner = text.slice(2, text.endsWith('*/') ? -2 : undefined);
+        for (const line of inner.split('\n')) {
+            const cleaned = line.trim();
+            if (cleaned)
+                return cleaned;
+        }
+        return null;
+    }
+    if (text.startsWith('//')) {
+        const cleaned = text.replace(/^\/\/+\s?/, '').trim();
+        return cleaned || null;
+    }
+    return null;
+}
+// Declaration signature = source from the declaration start to its body
+// (or the declaration end when bodiless). Shared by the TS and Go
+// extractors; feeds symbolId hashing, so — like normalizeSignature — it
+// must stay one copy. Java forks its own (annotation exclusion + trailing
+// `;` strip) and can't share this.
+export function declSignature(decl, content) {
+    const body = decl.childForFieldName('body');
+    const sigEnd = body ? body.startIndex : decl.endIndex;
+    return normalizeSignature(content.slice(decl.startIndex, sigEnd));
+}
+// A comment sharing its line with the END of an earlier sibling is a
+// TRAILING comment on that statement (`var z int // about z`), not doc for
+// the next declaration. Shared by the Go and Java doc extractors.
+export function isTrailingComment(comment) {
+    const before = comment.previousSibling;
+    return before !== null && before.endPosition.row === comment.startPosition.row;
+}
+// Type names that appear more than once among `symbols` (restricted to
+// `kinds`). Same-name types share a simple-name FQN, so resolving calls
+// through them first-wins would bind to the WRONG type — callers pass the
+// result as `ResolveCallsOptions.ambiguousClassNames` to exclude them from
+// extract-time resolution. Shared by the Go and Java extractors (the kinds
+// set differs: Go class/interface/type, Java class/interface/enum).
+export function collectAmbiguousTypeNames(symbols, kinds) {
+    const seen = new Set();
+    const ambiguous = new Set();
+    for (const s of symbols) {
+        if (!kinds.has(s.kind))
+            continue;
+        if (seen.has(s.name))
+            ambiguous.add(s.name);
+        else
+            seen.add(s.name);
+    }
+    return ambiguous;
+}
+export function resolveCalls(bodies, moduleRoot, symbols, fileInfo, selectors, skipTypes, functionBodySkipTypes, memberCallInfo, opts) {
+    const bareCalleeTypes = opts?.bareCalleeTypes ?? DEFAULT_BARE_CALLEE_TYPES;
+    const bindToEnclosingClass = opts?.bareCallsBindToEnclosingClass ?? false;
+    const bareCallableKinds = opts?.bareCallableKinds;
+    const constructorKinds = opts?.constructorKinds;
+    const ambiguousClassNames = opts?.ambiguousClassNames;
+    const ignoredBareCallees = opts?.ignoredBareCallees;
+    const plainCalleeType = opts?.plainCalleeType ?? 'identifier';
+    const constructorSelectorTypes = opts?.constructorSelectorTypes;
+    const ambiguousBareCallees = opts?.ambiguousBareCallees;
+    const ignoredMemberCallees = opts?.ignoredMemberCallees;
+    const nameToId = new Map();
+    for (const sym of symbols) {
+        if (bareCallableKinds ? !bareCallableKinds.has(sym.kind) : NON_CALLABLE_KINDS.has(sym.kind)) {
+            continue;
+        }
+        // An ambiguous bare-callable name (same name on >1 symbol — e.g. cross-namespace
+        // same-name functions in one file) stays out: first-wins would bind a bare call
+        // to the wrong one, so leave it unresolved instead.
+        if (ambiguousBareCallees?.has(sym.name))
+            continue;
+        if (!nameToId.has(sym.name))
+            nameToId.set(sym.name, sym.id);
+    }
+    // Constructor-form name map (`new X()` callees), built only when the
+    // language configures it. Ambiguous names stay out: binding first-wins
+    // between two same-named types would be confidently wrong.
+    const typeNameToId = new Map();
+    if (constructorKinds) {
+        for (const sym of symbols) {
+            if (!constructorKinds.has(sym.kind))
+                continue;
+            if (ambiguousClassNames?.has(sym.name))
+                continue;
+            if (!typeNameToId.has(sym.name))
+                typeNameToId.set(sym.name, sym.id);
+        }
+    }
+    // Methods stay out of `nameToId` (a bare `m()` never binds to one) but
+    // member calls resolve through their class: `this.m()` / `Class.m()`.
+    // The class name only lives in the fqn (`file:Class.method`).
+    const methodsByClass = new Map();
+    for (const sym of symbols) {
+        if (sym.kind !== 'method')
+            continue;
+        const cls = classNameFromFqn(sym.fqn);
+        if (!cls || ambiguousClassNames?.has(cls))
+            continue;
+        let methods = methodsByClass.get(cls);
+        if (!methods)
+            methodsByClass.set(cls, (methods = new Map()));
+        if (!methods.has(sym.name))
+            methods.set(sym.name, sym.id);
+    }
+    const calleeByType = new Map(selectors.map((s) => [s.nodeType, s.getCallee]));
+    const references = [];
+    const seenCallNodeIds = new Set();
+    const emit = (node, sourceId, className, selfReceiverName) => {
+        if (seenCallNodeIds.has(node.id))
+            return;
+        const getCallee = calleeByType.get(node.type);
+        if (!getCallee)
+            return;
+        const callee = getCallee(node);
+        if (!callee)
+            return;
+        if (bareCalleeTypes.has(callee.type)) {
+            seenCallNodeIds.add(node.id);
+            const targetName = callee.text;
+            // Constructor-form callees resolve against type symbols only. This is
+            // either a callee node type that isn't the plain bare type (Java's
+            // type_identifier from `new X()`) OR a call NODE in
+            // constructorSelectorTypes (C#'s object_creation_expression, whose callee
+            // IS a plain identifier — so it must be recognized by node, not callee,
+            // type; otherwise `new Foo()` would mis-bind to an enclosing METHOD Foo).
+            // Identifier callees that are NOT constructor-form resolve via the
+            // enclosing class when configured, then the callable-name map. Either way
+            // the ref stays a plain bare ref — the call site has no receiver token.
+            const isConstructorForm = (constructorSelectorTypes?.has(node.type) ?? false) || callee.type !== plainCalleeType;
+            const targetId = isConstructorForm
+                ? typeNameToId.get(targetName) ?? null
+                : ((bindToEnclosingClass && className !== undefined
+                    ? methodsByClass.get(className)?.get(targetName)
+                    : undefined) ??
+                    nameToId.get(targetName) ??
+                    null);
+            // Ignored names (Go builtins) are dropped only when unresolved — the
+            // node is already in seenCallNodeIds, so the moduleRoot re-walk stays
+            // cheap and never re-emits it.
+            if (targetId === null && !isConstructorForm && ignoredBareCallees?.has(targetName)) {
+                return;
+            }
+            references.push({
+                sourceId,
+                targetId,
+                targetName,
+                kind: 'calls',
+                file: fileInfo.path,
+                line: node.startPosition.row + 1,
+            });
+            return;
+        }
+        // Member-expression callee (`obj.method()`, `this.x()`, `new ns.X()`).
+        // Single-level receivers carry their token; chained/computed receivers
+        // carry RECEIVER_OPAQUE and flow through here as unresolved name-keyed
+        // member refs (recall — never resolved). The reader returns null only for
+        // `super`/`base`/`parent::` and computed-property calls with no clean name.
+        // (JSX member components and bare member decorators never reach here —
+        // their selectors return null for non-identifier names.)
+        const member = memberCallInfo(callee);
+        if (!member)
+            return;
+        seenCallNodeIds.add(node.id);
+        // Selfness comes from the reader (TS `this` node, Python self/cls) or,
+        // for Go, from the receiver token matching the enclosing method's
+        // declared receiver variable (PendingBody.selfReceiverName).
+        const isSelf = member.isSelf ||
+            (selfReceiverName !== undefined && member.receiver === selfReceiverName);
+        const lookupClass = isSelf ? className : member.receiver;
+        const targetId = (lookupClass ? methodsByClass.get(lookupClass)?.get(member.property) : undefined) ??
+            null;
+        // Dominant fluent/stdlib method names (`.filter()`, `.then()`, ...) flood
+        // the name-keyed store once chained/member calls are captured. Drop them
+        // only when UNRESOLVED — a same-file `this.filter()` that bound to a real
+        // sibling method keeps its ref. Node is already in seenCallNodeIds, so the
+        // moduleRoot re-walk stays cheap and never re-emits it. Qualified PATH calls
+        // (`crate::cfg::parse()`) are EXEMPT: they're a small intra-crate population,
+        // not the dot-method flood, so suppressing them would defeat path-call recall.
+        if (targetId === null && !member.pathQualified && ignoredMemberCallees?.has(member.property)) {
+            return;
+        }
+        const ref = {
+            sourceId,
+            targetId,
+            targetName: member.property,
+            kind: 'calls',
+            file: fileInfo.path,
+            line: node.startPosition.row + 1,
+            receiver: member.receiver,
+        };
+        // Recorded so isCallerOf can reject unresolved self-calls without
+        // guessing from the receiver token (`self` is a legal TS identifier).
+        // Gated on an enclosing class actually existing: `self.x()` in a
+        // plain Python function (or `this.x()` in a plain JS function) has
+        // no class instance to refer to and stays an ordinary member ref.
+        if (isSelf && className !== undefined)
+            ref.selfReceiver = true;
+        references.push(ref);
+    };
+    // Languages without a decorator selector (Java) skip the decorator walk
+    // entirely — it could never match and would re-traverse every subtree.
+    const hasDecoratorSelector = calleeByType.has('decorator');
+    // Body walks first so a function-nested decorator gets attributed to the
+    // enclosing body when reachable; the seen-set then drops the (null-sourced)
+    // module-root duplicate.
+    for (const { symbolId: sourceId, body, className, selfReceiverName } of bodies) {
+        walkCalls(body, calleeByType, skipTypes, (call) => emit(call, sourceId, className, selfReceiverName));
+        // TS decorators sit under skip-typed parents (class_declaration etc.)
+        // that walkCalls can't enter — walkDecorators descends through them
+        // so nested decorated classes attribute to the enclosing body.
+        if (hasDecoratorSelector) {
+            walkDecorators(body, calleeByType, skipTypes, functionBodySkipTypes, (call) => emit(call, sourceId, className, selfReceiverName));
+        }
+    }
+    if (moduleRoot) {
+        walkCalls(moduleRoot, calleeByType, skipTypes, (call) => emit(call, null));
+        if (hasDecoratorSelector) {
+            walkDecorators(moduleRoot, calleeByType, skipTypes, functionBodySkipTypes, (call) => emit(call, null));
+        }
+    }
+    return references;
+}
+function walkCalls(node, calleeByType, skipTypes, onCall) {
+    if (calleeByType.has(node.type))
+        onCall(node);
+    for (const child of node.namedChildren) {
+        if (skipTypes.has(child.type))
+            continue;
+        walkCalls(child, calleeByType, skipTypes, onCall);
+    }
+}
+function walkDecorators(node, calleeByType, skipTypes, functionBodySkipTypes, onCall) {
+    if (node.type === 'decorator') {
+        walkCalls(node, calleeByType, skipTypes, onCall);
+        return;
+    }
+    for (const child of node.namedChildren) {
+        // Skip nested function bodies — decorators inside a nested function
+        // only fire when that function is invoked, so they shouldn't
+        // attribute to the enclosing body. Class types stay descended so
+        // top-level decorators on inner classes still attribute correctly
+        // (the original walkDecorators rationale, mirrored by walkCalls
+        // skipping classes via skipTypes).
+        if (functionBodySkipTypes.has(child.type))
+            continue;
+        walkDecorators(child, calleeByType, skipTypes, functionBodySkipTypes, onCall);
+    }
+}