driftdetect-core 0.7.1 → 0.8.0

package/dist/call-graph/extractors/rust-hybrid-extractor.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Rust Hybrid Extractor
+ *
+ * Combines tree-sitter (primary) with regex fallback for enterprise-grade
+ * Rust code extraction. Provides confidence tracking and graceful degradation.
+ *
+ * @requirements Rust Language Support
+ */
+import { HybridExtractorBase } from './hybrid-extractor-base.js';
+import { RustRegexExtractor } from './regex/rust-regex.js';
+import type { CallGraphLanguage, FileExtractionResult } from '../types.js';
+import type { HybridExtractorConfig } from './types.js';
+/**
+ * Rust hybrid extractor combining tree-sitter and regex
+ */
+export declare class RustHybridExtractor extends HybridExtractorBase {
+    readonly language: CallGraphLanguage;
+    readonly extensions: string[];
+    protected regexExtractor: RustRegexExtractor;
+    private parser;
+    constructor(config?: HybridExtractorConfig);
+    /**
+     * Check if tree-sitter is available for Rust
+     */
+    protected isTreeSitterAvailable(): boolean;
+    /**
+     * Extract using tree-sitter
+     */
+    protected extractWithTreeSitter(source: string, filePath: string): FileExtractionResult | null;
+    /**
+     * Extract module name from file path
+     */
+    private extractModuleName;
+    /**
+     * Visit a tree-sitter node and extract information
+     */
+    private visitNode;
+    /**
+     * Extract a function item
+     */
+    private extractFunctionItem;
+    /**
+     * Extract an impl block
+     */
+    private extractImplItem;
+    /**
+     * Extract a trait definition
+     */
+    private extractTraitItem;
+    /**
+     * Extract a struct definition
+     */
+    private extractStructItem;
+    /**
+     * Extract an enum definition
+     */
+    private extractEnumItem;
+    /**
+     * Extract use declaration
+     */
+    private extractUseDeclaration;
+    /**
+     * Extract imports from use tree
+     */
+    private extractUseTree;
+    /**
+     * Extract call expression
+     */
+    private extractCallExpression;
+    /**
+     * Extract method call expression
+     */
+    private extractMethodCallExpression;
+    /**
+     * Extract macro invocation
+     */
+    private extractMacroInvocation;
+    /**
+     * Extract calls from a function body
+     */
+    private extractCallsFromBody;
+    /**
+     * Extract parameters from parameter list
+     */
+    private extractParameters;
+    /**
+     * Check if parameters include self
+     */
+    private hasSelfParameter;
+    /**
+     * Extract return type
+     */
+    private extractReturnType;
+    /**
+     * Extract type name from type node
+     */
+    private extractTypeName;
+    /**
+     * Check for visibility modifier
+     */
+    private hasVisibilityModifier;
+    /**
+     * Check for other modifiers
+     */
+    private hasModifier;
+    /**
+     * Extract attributes (decorators)
+     */
+    private extractAttributes;
+    /**
+     * Count arguments in argument list
+     */
+    private countArguments;
+}
+/**
+ * Create a Rust hybrid extractor instance
+ */
+export declare function createRustHybridExtractor(config?: HybridExtractorConfig): RustHybridExtractor;
+//# sourceMappingURL=rust-hybrid-extractor.d.ts.map

package/dist/call-graph/extractors/rust-hybrid-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-hybrid-extractor.d.ts","sourceRoot":"","sources":["../../../src/call-graph/extractors/rust-hybrid-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAiB,MAAM,aAAa,CAAC;AAG1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,mBAAmB;IAC1D,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAU;IAC9C,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAW;IACxC,SAAS,CAAC,cAAc,qBAA4B;IAEpD,OAAO,CAAC,MAAM,CAAiC;gBAEnC,MAAM,CAAC,EAAE,qBAAqB;IAI1C;;OAEG;IACH,SAAS,CAAC,qBAAqB,IAAI,OAAO;IAI1C;;OAEG;IACH,SAAS,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAgC9F;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,SAAS;IAmDjB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiD3B;;OAEG;IACH,OAAO,CAAC,eAAe;IA4BvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4CxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;OAEG;IACH,OAAO,CAAC,cAAc;IAgEtB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA+C7B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAuBnC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoB5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoBzB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAWxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAS7B;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;OAEG;IACH,OAAO,CAAC,cAAc;CASvB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,mBAAmB,CAE7F"}

package/dist/call-graph/extractors/rust-hybrid-extractor.js

@@ -0,0 +1,548 @@
+/**
+ * Rust Hybrid Extractor
+ *
+ * Combines tree-sitter (primary) with regex fallback for enterprise-grade
+ * Rust code extraction. Provides confidence tracking and graceful degradation.
+ *
+ * @requirements Rust Language Support
+ */
+import { HybridExtractorBase } from './hybrid-extractor-base.js';
+import { RustRegexExtractor } from './regex/rust-regex.js';
+import { isRustTreeSitterAvailable, createRustParser } from '../../parsers/tree-sitter/rust-loader.js';
+/**
+ * Rust hybrid extractor combining tree-sitter and regex
+ */
+export class RustHybridExtractor extends HybridExtractorBase {
+    language = 'rust';
+    extensions = ['.rs'];
+    regexExtractor = new RustRegexExtractor();
+    parser = null;
+    constructor(config) {
+        super(config);
+    }
+    /**
+     * Check if tree-sitter is available for Rust
+     */
+    isTreeSitterAvailable() {
+        return isRustTreeSitterAvailable();
+    }
+    /**
+     * Extract using tree-sitter
+     */
+    extractWithTreeSitter(source, filePath) {
+        if (!isRustTreeSitterAvailable()) {
+            return null;
+        }
+        const result = {
+            file: filePath,
+            language: this.language,
+            functions: [],
+            calls: [],
+            imports: [],
+            exports: [],
+            classes: [],
+            errors: [],
+        };
+        try {
+            if (!this.parser) {
+                this.parser = createRustParser();
+            }
+            const tree = this.parser.parse(source);
+            const moduleName = this.extractModuleName(filePath);
+            this.visitNode(tree.rootNode, result, source, null, moduleName);
+        }
+        catch (error) {
+            result.errors.push(error instanceof Error ? error.message : 'Unknown parse error');
+        }
+        return result;
+    }
+    /**
+     * Extract module name from file path
+     */
+    extractModuleName(filePath) {
+        const parts = filePath.split('/');
+        const fileName = parts[parts.length - 1] ?? 'main';
+        return fileName.replace('.rs', '');
+    }
+    /**
+     * Visit a tree-sitter node and extract information
+     */
+    visitNode(node, result, source, currentImpl, currentModule) {
+        switch (node.type) {
+            case 'function_item':
+                this.extractFunctionItem(node, result, source, currentImpl, currentModule);
+                break;
+            case 'impl_item':
+                this.extractImplItem(node, result, source, currentModule);
+                return;
+            case 'trait_item':
+                this.extractTraitItem(node, result, currentModule);
+                return;
+            case 'struct_item':
+                this.extractStructItem(node, result, currentModule);
+                break;
+            case 'enum_item':
+                this.extractEnumItem(node, result, currentModule);
+                break;
+            case 'use_declaration':
+                this.extractUseDeclaration(node, result);
+                break;
+            case 'call_expression':
+                this.extractCallExpression(node, result);
+                break;
+            case 'method_call_expression':
+                this.extractMethodCallExpression(node, result);
+                break;
+            case 'macro_invocation':
+                this.extractMacroInvocation(node, result);
+                break;
+            default:
+                for (const child of node.children) {
+                    this.visitNode(child, result, source, currentImpl, currentModule);
+                }
+        }
+    }
+    /**
+     * Extract a function item
+     */
+    extractFunctionItem(node, result, _source, currentImpl, currentModule) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return;
+        const name = nameNode.text;
+        const isPublic = this.hasVisibilityModifier(node, 'pub');
+        const isAsync = this.hasModifier(node, 'async');
+        const parametersNode = node.childForFieldName('parameters');
+        const returnTypeNode = node.childForFieldName('return_type');
+        const bodyNode = node.childForFieldName('body');
+        const parameters = parametersNode ? this.extractParameters(parametersNode) : [];
+        const returnType = returnTypeNode ? this.extractReturnType(returnTypeNode) : undefined;
+        const qualifiedName = currentImpl
+            ? `${currentModule}::${currentImpl}::${name}`
+            : `${currentModule}::${name}`;
+        result.functions.push({
+            name,
+            qualifiedName,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            startColumn: node.startPosition.column,
+            endColumn: node.endPosition.column,
+            parameters,
+            returnType,
+            isMethod: currentImpl !== null,
+            isStatic: currentImpl !== null && !this.hasSelfParameter(parametersNode),
+            isExported: isPublic,
+            isConstructor: name === 'new' || name === 'default',
+            isAsync,
+            className: currentImpl ?? undefined,
+            decorators: this.extractAttributes(node),
+            bodyStartLine: bodyNode ? bodyNode.startPosition.row + 1 : node.startPosition.row + 1,
+            bodyEndLine: bodyNode ? bodyNode.endPosition.row + 1 : node.endPosition.row + 1,
+        });
+        if (bodyNode) {
+            this.extractCallsFromBody(bodyNode, result);
+        }
+    }
+    /**
+     * Extract an impl block
+     */
+    extractImplItem(node, result, source, currentModule) {
+        const typeNode = node.childForFieldName('type');
+        const traitNode = node.childForFieldName('trait');
+        if (!typeNode)
+            return;
+        let implName = this.extractTypeName(typeNode);
+        if (traitNode) {
+            const traitName = this.extractTypeName(traitNode);
+            implName = `${traitName} for ${implName}`;
+        }
+        const bodyNode = node.childForFieldName('body');
+        if (bodyNode) {
+            for (const child of bodyNode.children) {
+                if (child.type === 'function_item') {
+                    this.extractFunctionItem(child, result, source, implName, currentModule);
+                }
+            }
+        }
+    }
+    /**
+     * Extract a trait definition
+     */
+    extractTraitItem(node, result, _currentModule) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return;
+        const name = nameNode.text;
+        const isPublic = this.hasVisibilityModifier(node, 'pub');
+        const methods = [];
+        const baseClasses = [];
+        const boundsNode = node.childForFieldName('bounds');
+        if (boundsNode) {
+            for (const child of boundsNode.children) {
+                if (child.type === 'type_identifier' || child.type === 'scoped_type_identifier') {
+                    baseClasses.push(child.text);
+                }
+            }
+        }
+        const bodyNode = node.childForFieldName('body');
+        if (bodyNode) {
+            for (const child of bodyNode.children) {
+                if (child.type === 'function_signature_item' || child.type === 'function_item') {
+                    const methodNameNode = child.childForFieldName('name');
+                    if (methodNameNode) {
+                        methods.push(methodNameNode.text);
+                    }
+                }
+            }
+        }
+        result.classes.push({
+            name,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            baseClasses,
+            methods,
+            isExported: isPublic,
+        });
+    }
+    /**
+     * Extract a struct definition
+     */
+    extractStructItem(node, result, _currentModule) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return;
+        const name = nameNode.text;
+        const isPublic = this.hasVisibilityModifier(node, 'pub');
+        result.classes.push({
+            name,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            baseClasses: [],
+            methods: [],
+            isExported: isPublic,
+        });
+    }
+    /**
+     * Extract an enum definition
+     */
+    extractEnumItem(node, result, _currentModule) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return;
+        const name = nameNode.text;
+        const isPublic = this.hasVisibilityModifier(node, 'pub');
+        result.classes.push({
+            name,
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            baseClasses: [],
+            methods: [],
+            isExported: isPublic,
+        });
+    }
+    /**
+     * Extract use declaration
+     */
+    extractUseDeclaration(node, result) {
+        const argumentNode = node.childForFieldName('argument');
+        if (!argumentNode)
+            return;
+        const imports = this.extractUseTree(argumentNode);
+        for (const imp of imports) {
+            result.imports.push({
+                source: imp.source,
+                names: [{
+                        imported: imp.name,
+                        local: imp.alias ?? imp.name,
+                        isDefault: false,
+                        isNamespace: imp.isGlob,
+                    }],
+                line: node.startPosition.row + 1,
+                isTypeOnly: false,
+            });
+        }
+    }
+    /**
+     * Extract imports from use tree
+     */
+    extractUseTree(node) {
+        const imports = [];
+        if (node.type === 'scoped_identifier' || node.type === 'identifier') {
+            const path = node.text;
+            const parts = path.split('::');
+            const name = parts[parts.length - 1] ?? path;
+            imports.push({ source: path, name, isGlob: false });
+        }
+        else if (node.type === 'use_wildcard') {
+            const pathNode = node.childForFieldName('path');
+            imports.push({ source: pathNode?.text ?? '', name: '*', isGlob: true });
+        }
+        else if (node.type === 'use_as_clause') {
+            const pathNode = node.childForFieldName('path');
+            const aliasNode = node.childForFieldName('alias');
+            const path = pathNode?.text ?? '';
+            const parts = path.split('::');
+            const name = parts[parts.length - 1] ?? path;
+            const aliasText = aliasNode?.text;
+            imports.push({ source: path, name, ...(aliasText ? { alias: aliasText } : {}), isGlob: false });
+        }
+        else if (node.type === 'scoped_use_list') {
+            const pathNode = node.childForFieldName('path');
+            const listNode = node.childForFieldName('list');
+            const basePath = pathNode?.text ?? '';
+            if (listNode) {
+                for (const child of listNode.children) {
+                    if (child.type === 'identifier') {
+                        imports.push({
+                            source: basePath ? `${basePath}::${child.text}` : child.text,
+                            name: child.text,
+                            isGlob: false,
+                        });
+                    }
+                    else if (child.type === 'self') {
+                        imports.push({
+                            source: basePath,
+                            name: basePath.split('::').pop() ?? basePath,
+                            isGlob: false,
+                        });
+                    }
+                    else if (child.type !== '{' && child.type !== '}' && child.type !== ',') {
+                        const subImports = this.extractUseTree(child);
+                        for (const sub of subImports) {
+                            imports.push({
+                                ...sub,
+                                source: basePath ? `${basePath}::${sub.source}` : sub.source,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return imports;
+    }
+    /**
+     * Extract call expression
+     */
+    extractCallExpression(node, result) {
+        const funcNode = node.childForFieldName('function');
+        const argsNode = node.childForFieldName('arguments');
+        if (!funcNode)
+            return;
+        let calleeName;
+        let receiver;
+        let isMethodCall = false;
+        if (funcNode.type === 'scoped_identifier') {
+            calleeName = funcNode.text;
+            const parts = calleeName.split('::');
+            if (parts.length > 1) {
+                receiver = parts.slice(0, -1).join('::');
+                calleeName = parts[parts.length - 1] ?? calleeName;
+            }
+        }
+        else if (funcNode.type === 'field_expression') {
+            const fieldNode = funcNode.childForFieldName('field');
+            const valueNode = funcNode.childForFieldName('value');
+            if (fieldNode && valueNode) {
+                receiver = valueNode.text;
+                calleeName = fieldNode.text;
+                isMethodCall = true;
+            }
+            else {
+                calleeName = funcNode.text;
+            }
+        }
+        else if (funcNode.type === 'identifier') {
+            calleeName = funcNode.text;
+        }
+        else {
+            calleeName = funcNode.text;
+        }
+        const argumentCount = argsNode ? this.countArguments(argsNode) : 0;
+        result.calls.push({
+            calleeName,
+            receiver,
+            fullExpression: node.text,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            argumentCount,
+            isMethodCall,
+            isConstructorCall: calleeName === 'new' || calleeName === 'default',
+        });
+    }
+    /**
+     * Extract method call expression
+     */
+    extractMethodCallExpression(node, result) {
+        const nameNode = node.childForFieldName('name');
+        const receiverNode = node.childForFieldName('value');
+        const argsNode = node.childForFieldName('arguments');
+        if (!nameNode)
+            return;
+        const calleeName = nameNode.text;
+        const receiver = receiverNode?.text;
+        const argumentCount = argsNode ? this.countArguments(argsNode) : 0;
+        result.calls.push({
+            calleeName,
+            receiver,
+            fullExpression: node.text,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            argumentCount,
+            isMethodCall: true,
+            isConstructorCall: calleeName === 'new' || calleeName === 'default',
+        });
+    }
+    /**
+     * Extract macro invocation
+     */
+    extractMacroInvocation(node, result) {
+        const macroNode = node.childForFieldName('macro');
+        if (!macroNode)
+            return;
+        const calleeName = macroNode.text + '!';
+        result.calls.push({
+            calleeName,
+            fullExpression: node.text,
+            line: node.startPosition.row + 1,
+            column: node.startPosition.column,
+            argumentCount: 0,
+            isMethodCall: false,
+            isConstructorCall: false,
+        });
+    }
+    /**
+     * Extract calls from a function body
+     */
+    extractCallsFromBody(node, result) {
+        const visit = (n) => {
+            if (n.type === 'call_expression') {
+                this.extractCallExpression(n, result);
+            }
+            else if (n.type === 'method_call_expression') {
+                this.extractMethodCallExpression(n, result);
+            }
+            else if (n.type === 'macro_invocation') {
+                this.extractMacroInvocation(n, result);
+            }
+            for (const child of n.children) {
+                visit(child);
+            }
+        };
+        for (const child of node.children) {
+            visit(child);
+        }
+    }
+    /**
+     * Extract parameters from parameter list
+     */
+    extractParameters(node) {
+        const params = [];
+        for (const child of node.children) {
+            if (child.type === 'parameter') {
+                const patternNode = child.childForFieldName('pattern');
+                const typeNode = child.childForFieldName('type');
+                const name = patternNode?.text ?? '_';
+                const type = typeNode?.text;
+                params.push({ name, type, hasDefault: false, isRest: false });
+            }
+            else if (child.type === 'self_parameter') {
+                params.push({ name: 'self', type: child.text, hasDefault: false, isRest: false });
+            }
+        }
+        return params;
+    }
+    /**
+     * Check if parameters include self
+     */
+    hasSelfParameter(parametersNode) {
+        if (!parametersNode)
+            return false;
+        for (const child of parametersNode.children) {
+            if (child.type === 'self_parameter') {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Extract return type
+     */
+    extractReturnType(node) {
+        const typeNode = node.namedChildren[0];
+        return typeNode?.text ?? node.text.replace(/^->\s*/, '');
+    }
+    /**
+     * Extract type name from type node
+     */
+    extractTypeName(node) {
+        if (node.type === 'type_identifier') {
+            return node.text;
+        }
+        else if (node.type === 'scoped_type_identifier') {
+            return node.text;
+        }
+        else if (node.type === 'generic_type') {
+            const typeNode = node.childForFieldName('type');
+            return typeNode?.text ?? node.text;
+        }
+        return node.text;
+    }
+    /**
+     * Check for visibility modifier
+     */
+    hasVisibilityModifier(node, modifier) {
+        for (const child of node.children) {
+            if (child.type === 'visibility_modifier') {
+                return child.text.startsWith(modifier);
+            }
+        }
+        return false;
+    }
+    /**
+     * Check for other modifiers
+     */
+    hasModifier(node, modifier) {
+        for (const child of node.children) {
+            if (child.type === modifier || child.text === modifier) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Extract attributes (decorators)
+     */
+    extractAttributes(node) {
+        const attributes = [];
+        let sibling = node.previousSibling;
+        while (sibling) {
+            if (sibling.type === 'attribute_item') {
+                attributes.push(sibling.text);
+            }
+            else if (sibling.type !== 'line_comment' && sibling.type !== 'block_comment') {
+                break;
+            }
+            sibling = sibling.previousSibling;
+        }
+        return attributes.reverse();
+    }
+    /**
+     * Count arguments in argument list
+     */
+    countArguments(argsNode) {
+        let count = 0;
+        for (const child of argsNode.children) {
+            if (child.type !== '(' && child.type !== ')' && child.type !== ',') {
+                count++;
+            }
+        }
+        return count;
+    }
+}
+/**
+ * Create a Rust hybrid extractor instance
+ */
+export function createRustHybridExtractor(config) {
+    return new RustHybridExtractor(config);
+}
+//# sourceMappingURL=rust-hybrid-extractor.js.map