driftdetect-core 0.5.0 → 0.6.1

package/dist/parsers/tree-sitter/tree-sitter-go-parser.js

@@ -0,0 +1,707 @@
+/**
+ * Tree-sitter Go Parser
+ *
+ * Full Go parser using tree-sitter-go for semantic extraction.
+ * Extracts packages, imports, structs, interfaces, functions,
+ * methods, and type declarations from Go source files.
+ *
+ * Supports Go-specific features including receivers, embedded types,
+ * multiple return values, and interface embedding.
+ *
+ * @requirements Go Language Support
+ */
+import { isGoTreeSitterAvailable, createGoParser, getGoLoadingError, } from './go-loader.js';
+// ============================================
+// Parser Class
+// ============================================
+/**
+ * Go parser using tree-sitter-go.
+ *
+ * Provides full semantic extraction for Go source files including:
+ * - Package declarations
+ * - Import statements
+ * - Function and method declarations
+ * - Struct and interface declarations
+ * - Type aliases
+ */
+export class TreeSitterGoParser {
+    parser = null;
+    initError = null;
+    /**
+     * Check if the parser is available.
+     */
+    isAvailable() {
+        return isGoTreeSitterAvailable();
+    }
+    /**
+     * Get the initialization error if parser is not available.
+     */
+    getError() {
+        return this.initError ?? getGoLoadingError();
+    }
+    /**
+     * Initialize the parser.
+     * Call this before parsing or check isAvailable() first.
+     */
+    initialize() {
+        if (this.parser) {
+            return true;
+        }
+        if (!isGoTreeSitterAvailable()) {
+            this.initError = getGoLoadingError() ?? 'tree-sitter-go not available';
+            return false;
+        }
+        try {
+            this.parser = createGoParser();
+            return true;
+        }
+        catch (error) {
+            this.initError = error instanceof Error ? error.message : 'Failed to create Go parser';
+            return false;
+        }
+    }
+    /**
+     * Parse Go source code and extract semantic information.
+     *
+     * @param source - Go source code
+     * @param filePath - Optional file path for error reporting
+     * @returns GoParseResult with full semantic information
+     */
+    parse(source, _filePath) {
+        // Ensure parser is initialized
+        if (!this.parser && !this.initialize()) {
+            return this.createErrorResult(this.initError ?? 'Parser not initialized');
+        }
+        if (!this.parser) {
+            return this.createErrorResult('Parser not available');
+        }
+        try {
+            // Parse the source
+            const tree = this.parser.parse(source);
+            const rootNode = tree.rootNode;
+            // Extract semantic information
+            const packageInfo = this.extractPackage(rootNode);
+            const imports = this.extractImports(rootNode);
+            const packageName = packageInfo?.name ?? 'main';
+            // Extract declarations
+            const functions = this.extractFunctions(rootNode, packageName);
+            const methods = this.extractMethods(rootNode, packageName);
+            const structs = this.extractStructs(rootNode);
+            const interfaces = this.extractInterfaces(rootNode);
+            const typeAliases = this.extractTypeAliases(rootNode);
+            // Convert to AST for base result
+            const ast = this.convertToAST(rootNode, source);
+            return {
+                success: true,
+                language: 'go',
+                ast,
+                errors: [],
+                package: packageInfo,
+                imports,
+                functions,
+                methods,
+                structs,
+                interfaces,
+                typeAliases,
+            };
+        }
+        catch (error) {
+            return this.createErrorResult(error instanceof Error ? error.message : 'Parse error');
+        }
+    }
+    // ============================================
+    // Extraction Methods
+    // ============================================
+    /**
+     * Extract package declaration from the AST.
+     */
+    extractPackage(root) {
+        const packageNode = this.findChildByType(root, 'package_clause');
+        if (!packageNode) {
+            return null;
+        }
+        const nameNode = packageNode.childForFieldName('name') ??
+            this.findChildByType(packageNode, 'package_identifier');
+        if (!nameNode) {
+            return null;
+        }
+        return {
+            name: nameNode.text,
+            startPosition: this.toPosition(packageNode.startPosition),
+            endPosition: this.toPosition(packageNode.endPosition),
+        };
+    }
+    /**
+     * Extract import statements from the AST.
+     */
+    extractImports(root) {
+        const imports = [];
+        this.findNodesOfType(root, 'import_declaration', (node) => {
+            // Handle import spec list (grouped imports)
+            this.findNodesOfType(node, 'import_spec', (specNode) => {
+                const importInfo = this.parseImportSpec(specNode);
+                if (importInfo) {
+                    imports.push(importInfo);
+                }
+            });
+        });
+        return imports;
+    }
+    /**
+     * Parse a single import spec.
+     */
+    parseImportSpec(node) {
+        const pathNode = node.childForFieldName('path') ??
+            this.findChildByType(node, 'interpreted_string_literal');
+        if (!pathNode) {
+            return null;
+        }
+        // Remove quotes from path
+        const path = pathNode.text.replace(/^"|"$/g, '');
+        // Check for alias
+        const nameNode = node.childForFieldName('name') ??
+            this.findChildByType(node, 'package_identifier') ??
+            this.findChildByType(node, 'blank_identifier') ??
+            this.findChildByType(node, 'dot');
+        let alias = null;
+        let isBlankImport = false;
+        let isDotImport = false;
+        if (nameNode) {
+            if (nameNode.type === 'blank_identifier' || nameNode.text === '_') {
+                isBlankImport = true;
+                alias = '_';
+            }
+            else if (nameNode.type === 'dot' || nameNode.text === '.') {
+                isDotImport = true;
+                alias = '.';
+            }
+            else {
+                alias = nameNode.text;
+            }
+        }
+        return {
+            path,
+            alias,
+            isBlankImport,
+            isDotImport,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+        };
+    }
+    /**
+     * Extract function declarations (non-method functions).
+     */
+    extractFunctions(root, packageName) {
+        const functions = [];
+        this.findNodesOfType(root, 'function_declaration', (node) => {
+            const funcInfo = this.parseFunctionDeclaration(node, packageName);
+            if (funcInfo) {
+                functions.push(funcInfo);
+            }
+        });
+        return functions;
+    }
+    /**
+     * Parse a function declaration.
+     */
+    parseFunctionDeclaration(node, packageName) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) {
+            return null;
+        }
+        const name = nameNode.text;
+        const isExported = /^[A-Z]/.test(name);
+        const parametersNode = node.childForFieldName('parameters');
+        const resultNode = node.childForFieldName('result');
+        const bodyNode = node.childForFieldName('body');
+        const parameters = parametersNode ? this.extractParameters(parametersNode) : [];
+        const returns = resultNode ? this.extractReturns(resultNode) : [];
+        const isVariadic = parameters.some(p => p.isVariadic);
+        return {
+            name,
+            qualifiedName: `${packageName}.${name}`,
+            parameters,
+            returns,
+            isExported,
+            isVariadic,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+            bodyStartPosition: bodyNode ? this.toPosition(bodyNode.startPosition) : null,
+            bodyEndPosition: bodyNode ? this.toPosition(bodyNode.endPosition) : null,
+        };
+    }
+    /**
+     * Extract method declarations (functions with receivers).
+     */
+    extractMethods(root, packageName) {
+        const methods = [];
+        this.findNodesOfType(root, 'method_declaration', (node) => {
+            const methodInfo = this.parseMethodDeclaration(node, packageName);
+            if (methodInfo) {
+                methods.push(methodInfo);
+            }
+        });
+        return methods;
+    }
+    /**
+     * Parse a method declaration.
+     */
+    parseMethodDeclaration(node, packageName) {
+        const nameNode = node.childForFieldName('name');
+        const receiverNode = node.childForFieldName('receiver');
+        if (!nameNode || !receiverNode) {
+            return null;
+        }
+        const name = nameNode.text;
+        const isExported = /^[A-Z]/.test(name);
+        const receiver = this.parseReceiver(receiverNode);
+        if (!receiver) {
+            return null;
+        }
+        const parametersNode = node.childForFieldName('parameters');
+        const resultNode = node.childForFieldName('result');
+        const bodyNode = node.childForFieldName('body');
+        const parameters = parametersNode ? this.extractParameters(parametersNode) : [];
+        const returns = resultNode ? this.extractReturns(resultNode) : [];
+        const isVariadic = parameters.some(p => p.isVariadic);
+        return {
+            name,
+            qualifiedName: `${packageName}.${receiver.type}.${name}`,
+            receiver,
+            parameters,
+            returns,
+            isExported,
+            isVariadic,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+            bodyStartPosition: bodyNode ? this.toPosition(bodyNode.startPosition) : null,
+            bodyEndPosition: bodyNode ? this.toPosition(bodyNode.endPosition) : null,
+        };
+    }
+    /**
+     * Parse a receiver declaration.
+     */
+    parseReceiver(node) {
+        // Receiver is a parameter_list with one parameter
+        for (const child of node.children) {
+            if (child.type === 'parameter_declaration') {
+                const nameNode = this.findChildByType(child, 'identifier');
+                const typeNode = child.childForFieldName('type');
+                if (!typeNode)
+                    continue;
+                let typeName;
+                let isPointer = false;
+                if (typeNode.type === 'pointer_type') {
+                    isPointer = true;
+                    // Use namedChildren instead of namedChild
+                    const innerType = typeNode.namedChildren[0];
+                    typeName = innerType?.text ?? 'unknown';
+                }
+                else {
+                    typeName = typeNode.text;
+                }
+                return {
+                    name: nameNode?.text ?? '_',
+                    type: typeName,
+                    isPointer,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract parameters from a parameter list.
+     */
+    extractParameters(node) {
+        const params = [];
+        for (const child of node.children) {
+            if (child.type === 'parameter_declaration') {
+                const names = [];
+                let type;
+                let isVariadic = false;
+                for (const paramChild of child.children) {
+                    if (paramChild.type === 'identifier') {
+                        names.push(paramChild.text);
+                    }
+                    else if (paramChild.type === 'variadic_parameter_declaration') {
+                        isVariadic = true;
+                        const variadicType = paramChild.childForFieldName('type');
+                        type = variadicType?.text;
+                    }
+                    else if (this.isTypeNode(paramChild)) {
+                        type = paramChild.text;
+                    }
+                }
+                // If no names, it's an unnamed parameter
+                if (names.length === 0) {
+                    params.push({
+                        name: '_',
+                        type: type ?? 'unknown',
+                        isVariadic,
+                    });
+                }
+                else {
+                    for (const name of names) {
+                        params.push({
+                            name,
+                            type: type ?? 'unknown',
+                            isVariadic,
+                        });
+                    }
+                }
+            }
+            else if (child.type === 'variadic_parameter_declaration') {
+                const nameNode = this.findChildByType(child, 'identifier');
+                const typeNode = child.childForFieldName('type');
+                params.push({
+                    name: nameNode?.text ?? '_',
+                    type: typeNode?.text ?? 'unknown',
+                    isVariadic: true,
+                });
+            }
+        }
+        return params;
+    }
+    /**
+     * Extract return types from a result node.
+     */
+    extractReturns(node) {
+        const returns = [];
+        if (node.type === 'parameter_list') {
+            // Multiple/named returns: (int, error) or (result int, err error)
+            for (const child of node.children) {
+                if (child.type === 'parameter_declaration') {
+                    const names = [];
+                    let type;
+                    for (const paramChild of child.children) {
+                        if (paramChild.type === 'identifier') {
+                            names.push(paramChild.text);
+                        }
+                        else if (this.isTypeNode(paramChild)) {
+                            type = paramChild.text;
+                        }
+                    }
+                    if (names.length === 0) {
+                        returns.push({ name: null, type: type ?? 'unknown' });
+                    }
+                    else {
+                        for (const name of names) {
+                            returns.push({ name, type: type ?? 'unknown' });
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // Single return type
+            returns.push({ name: null, type: node.text });
+        }
+        return returns;
+    }
+    /**
+     * Extract struct declarations.
+     */
+    extractStructs(root) {
+        const structs = [];
+        this.findNodesOfType(root, 'type_declaration', (node) => {
+            for (const child of node.children) {
+                if (child.type === 'type_spec') {
+                    const nameNode = child.childForFieldName('name');
+                    const typeNode = child.childForFieldName('type');
+                    if (nameNode && typeNode?.type === 'struct_type') {
+                        const structInfo = this.parseStruct(nameNode.text, typeNode);
+                        if (structInfo) {
+                            structs.push(structInfo);
+                        }
+                    }
+                }
+            }
+        });
+        return structs;
+    }
+    /**
+     * Parse a struct type.
+     */
+    parseStruct(name, node) {
+        const isExported = /^[A-Z]/.test(name);
+        const fields = [];
+        const embeddedTypes = [];
+        const fieldListNode = node.childForFieldName('fields') ??
+            this.findChildByType(node, 'field_declaration_list');
+        if (fieldListNode) {
+            for (const child of fieldListNode.children) {
+                if (child.type === 'field_declaration') {
+                    const fieldInfo = this.parseField(child);
+                    if (fieldInfo) {
+                        if (fieldInfo.isEmbedded) {
+                            embeddedTypes.push(fieldInfo.type);
+                        }
+                        fields.push(fieldInfo);
+                    }
+                }
+            }
+        }
+        return {
+            name,
+            isExported,
+            fields,
+            embeddedTypes,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+        };
+    }
+    /**
+     * Parse a struct field.
+     */
+    parseField(node) {
+        const names = [];
+        let type;
+        let tag = null;
+        for (const child of node.children) {
+            if (child.type === 'field_identifier') {
+                names.push(child.text);
+            }
+            else if (this.isTypeNode(child)) {
+                type = child.text.replace(/^\*/, ''); // Remove pointer for embedded type check
+            }
+            else if (child.type === 'raw_string_literal' || child.type === 'interpreted_string_literal') {
+                tag = child.text;
+            }
+        }
+        if (!type) {
+            return null;
+        }
+        // Embedded type (no name, just type)
+        const isEmbedded = names.length === 0;
+        const fieldName = isEmbedded ? type : names[0];
+        const isExported = /^[A-Z]/.test(fieldName);
+        return {
+            name: fieldName,
+            type,
+            tag,
+            isExported,
+            isEmbedded,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+        };
+    }
+    /**
+     * Extract interface declarations.
+     */
+    extractInterfaces(root) {
+        const interfaces = [];
+        this.findNodesOfType(root, 'type_declaration', (node) => {
+            for (const child of node.children) {
+                if (child.type === 'type_spec') {
+                    const nameNode = child.childForFieldName('name');
+                    const typeNode = child.childForFieldName('type');
+                    if (nameNode && typeNode?.type === 'interface_type') {
+                        const interfaceInfo = this.parseInterface(nameNode.text, typeNode);
+                        if (interfaceInfo) {
+                            interfaces.push(interfaceInfo);
+                        }
+                    }
+                }
+            }
+        });
+        return interfaces;
+    }
+    /**
+     * Parse an interface type.
+     */
+    parseInterface(name, node) {
+        const isExported = /^[A-Z]/.test(name);
+        const methods = [];
+        const embeddedInterfaces = [];
+        for (const child of node.children) {
+            if (child.type === 'method_spec') {
+                const methodInfo = this.parseInterfaceMethod(child);
+                if (methodInfo) {
+                    methods.push(methodInfo);
+                }
+            }
+            else if (child.type === 'type_identifier' || child.type === 'qualified_type') {
+                // Embedded interface
+                embeddedInterfaces.push(child.text);
+            }
+        }
+        return {
+            name,
+            isExported,
+            methods,
+            embeddedInterfaces,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+        };
+    }
+    /**
+     * Parse an interface method signature.
+     */
+    parseInterfaceMethod(node) {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) {
+            return null;
+        }
+        const parametersNode = node.childForFieldName('parameters');
+        const resultNode = node.childForFieldName('result');
+        return {
+            name: nameNode.text,
+            parameters: parametersNode ? this.extractParameters(parametersNode) : [],
+            returns: resultNode ? this.extractReturns(resultNode) : [],
+        };
+    }
+    /**
+     * Extract type alias declarations.
+     */
+    extractTypeAliases(root) {
+        const aliases = [];
+        this.findNodesOfType(root, 'type_declaration', (node) => {
+            for (const child of node.children) {
+                if (child.type === 'type_spec') {
+                    const nameNode = child.childForFieldName('name');
+                    const typeNode = child.childForFieldName('type');
+                    if (nameNode && typeNode &&
+                        typeNode.type !== 'struct_type' &&
+                        typeNode.type !== 'interface_type') {
+                        aliases.push({
+                            name: nameNode.text,
+                            underlyingType: typeNode.text,
+                            isExported: /^[A-Z]/.test(nameNode.text),
+                            startPosition: this.toPosition(child.startPosition),
+                            endPosition: this.toPosition(child.endPosition),
+                        });
+                    }
+                }
+            }
+        });
+        return aliases;
+    }
+    // ============================================
+    // Utility Methods
+    // ============================================
+    /**
+     * Check if a node is a type node.
+     */
+    isTypeNode(node) {
+        const typeNodes = [
+            'type_identifier',
+            'pointer_type',
+            'slice_type',
+            'array_type',
+            'map_type',
+            'channel_type',
+            'function_type',
+            'qualified_type',
+            'struct_type',
+            'interface_type',
+        ];
+        return typeNodes.includes(node.type);
+    }
+    /**
+     * Convert tree-sitter AST to drift AST format.
+     */
+    convertToAST(node, source) {
+        const rootNode = this.convertNode(node);
+        return {
+            rootNode,
+            text: source,
+        };
+    }
+    /**
+     * Convert a single tree-sitter node to drift ASTNode.
+     */
+    convertNode(node) {
+        const children = [];
+        for (const child of node.children) {
+            children.push(this.convertNode(child));
+        }
+        return {
+            type: this.mapNodeType(node.type),
+            text: node.text,
+            children,
+            startPosition: this.toPosition(node.startPosition),
+            endPosition: this.toPosition(node.endPosition),
+        };
+    }
+    /**
+     * Map tree-sitter node types to drift node types.
+     */
+    mapNodeType(type) {
+        const typeMap = {
+            source_file: 'Program',
+            package_clause: 'PackageDeclaration',
+            import_declaration: 'ImportDeclaration',
+            function_declaration: 'FunctionDeclaration',
+            method_declaration: 'MethodDeclaration',
+            type_declaration: 'TypeDeclaration',
+            struct_type: 'StructType',
+            interface_type: 'InterfaceType',
+            identifier: 'Identifier',
+            type_identifier: 'TypeIdentifier',
+            block: 'Block',
+            return_statement: 'ReturnStatement',
+            if_statement: 'IfStatement',
+            for_statement: 'ForStatement',
+            go_statement: 'GoStatement',
+            defer_statement: 'DeferStatement',
+            call_expression: 'CallExpression',
+            selector_expression: 'SelectorExpression',
+        };
+        return typeMap[type] ?? type;
+    }
+    /**
+     * Convert tree-sitter position to drift Position.
+     */
+    toPosition(point) {
+        return {
+            row: point.row,
+            column: point.column,
+        };
+    }
+    /**
+     * Find a child node by type.
+     */
+    findChildByType(node, type) {
+        for (const child of node.children) {
+            if (child.type === type) {
+                return child;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find all nodes of a specific type in the tree.
+     */
+    findNodesOfType(node, type, callback) {
+        if (node.type === type) {
+            callback(node);
+        }
+        for (const child of node.children) {
+            this.findNodesOfType(child, type, callback);
+        }
+    }
+    /**
+     * Create an error result.
+     */
+    createErrorResult(message) {
+        return {
+            success: false,
+            language: 'go',
+            ast: null,
+            errors: [
+                {
+                    message,
+                    position: { row: 0, column: 0 },
+                },
+            ],
+            package: null,
+            imports: [],
+            functions: [],
+            methods: [],
+            structs: [],
+            interfaces: [],
+            typeAliases: [],
+        };
+    }
+}
+//# sourceMappingURL=tree-sitter-go-parser.js.map