linguclaw 0.4.0

package/dist/languages/go.js

@@ -0,0 +1,882 @@
+"use strict";
+/**
+ * Go Language Support for LinguClaw
+ * Advanced Go parser with goroutine and channel analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoLanguageSupport = exports.GoAnalyzer = exports.GoParser = void 0;
+class GoParser {
+    source = '';
+    lines = [];
+    parse(source, filePath) {
+        this.source = source;
+        this.lines = source.split('\n');
+        try {
+            const ast = this.parseGo(source, filePath);
+            return {
+                ast,
+                errors: this.findSyntaxErrors(),
+                warnings: [],
+                tokens: [],
+                comments: this.extractComments(),
+            };
+        }
+        catch (error) {
+            return this.fallbackParse(filePath);
+        }
+    }
+    async *parseStream(source) {
+        const reader = source.getReader();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += value;
+            // Go statements end with newlines or semicolons
+            const lines = buffer.split('\n');
+            const complete = [];
+            let remaining = '';
+            let braceCount = 0;
+            let parenCount = 0;
+            let inRawString = false;
+            for (const line of lines) {
+                for (let i = 0; i < line.length; i++) {
+                    const char = line[i];
+                    const nextChar = line[i + 1] || '';
+                    // Handle raw string literals
+                    if (char === '`') {
+                        inRawString = !inRawString;
+                    }
+                    if (!inRawString) {
+                        if (char === '{')
+                            braceCount++;
+                        if (char === '}')
+                            braceCount--;
+                        if (char === '(')
+                            parenCount++;
+                        if (char === ')')
+                            parenCount--;
+                    }
+                }
+                if (braceCount === 0 && parenCount === 0 && !inRawString) {
+                    complete.push(line);
+                }
+                else {
+                    remaining += line + '\n';
+                }
+            }
+            if (complete.length > 0) {
+                yield this.parse(complete.join('\n'), '<stream>');
+            }
+            buffer = remaining;
+        }
+        if (buffer.trim()) {
+            yield this.parse(buffer, '<stream>');
+        }
+    }
+    parseGo(source, filePath) {
+        const root = {
+            type: 'Program',
+            id: `${filePath}:0:0`,
+            location: this.createLocation(filePath, 0, 0, this.lines.length, 0),
+            children: [],
+            metadata: { language: 'go', package: '' },
+        };
+        // Parse package declaration
+        const packageMatch = source.match(/package\s+(\w+)/);
+        if (packageMatch) {
+            root.metadata.package = packageMatch[1];
+            root.children.push({
+                type: 'PackageDeclaration',
+                id: `${filePath}:1:0`,
+                location: this.createLocation(filePath, 1, 0, 1, packageMatch[0].length),
+                children: [],
+                metadata: { name: packageMatch[1] },
+            });
+        }
+        // Parse imports
+        const imports = this.parseImports(source, filePath);
+        root.children.push(...imports);
+        // Parse declarations
+        const declarations = this.parseDeclarations(source, filePath);
+        root.children.push(...declarations);
+        return root;
+    }
+    parseImports(source, filePath) {
+        const imports = [];
+        const importRegex = /import\s*(?:\(|([^)]+))/g;
+        let match;
+        while ((match = importRegex.exec(source)) !== null) {
+            if (match[1]) {
+                // Single import
+                const importPath = match[1].trim().replace(/["']/g, '');
+                const alias = match[1].match(/^(\w+)\s+/)?.[1];
+                imports.push({
+                    type: 'ImportDeclaration',
+                    id: `${filePath}:0:${match.index}`,
+                    location: this.createLocation(filePath, 0, match.index, 0, match.index + match[0].length),
+                    children: [],
+                    metadata: {
+                        path: importPath,
+                        alias,
+                        isStandard: !importPath.includes('.'),
+                        isCgo: importPath === 'C',
+                    },
+                });
+            }
+            else {
+                // Block import - find closing paren
+                const startIdx = match.index;
+                const blockEnd = this.findMatchingParen(source, startIdx + 6);
+                const blockContent = source.substring(startIdx + 7, blockEnd);
+                const blockLines = blockContent.split('\n');
+                for (const line of blockLines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith('//')) {
+                        const pathMatch = trimmed.match(/["']([^"']+)["']/);
+                        if (pathMatch) {
+                            const aliasMatch = trimmed.match(/^(\w+)\s+/);
+                            imports.push({
+                                type: 'ImportDeclaration',
+                                id: `${filePath}:0:0`,
+                                location: this.createLocation(filePath, 0, 0, 0, 0),
+                                children: [],
+                                metadata: {
+                                    path: pathMatch[1],
+                                    alias: aliasMatch?.[1],
+                                    isStandard: !pathMatch[1].includes('.'),
+                                    isCgo: pathMatch[1] === 'C',
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return imports;
+    }
+    parseDeclarations(source, filePath) {
+        const declarations = [];
+        const lines = source.split('\n');
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i].trim();
+            // Skip comments and empty lines
+            if (!line || line.startsWith('//')) {
+                i++;
+                continue;
+            }
+            // Type declarations
+            if (line.startsWith('type ')) {
+                const typeDecl = this.parseTypeDeclaration(lines, i, filePath);
+                if (typeDecl) {
+                    declarations.push(typeDecl.node);
+                    i = typeDecl.endIndex + 1;
+                    continue;
+                }
+            }
+            // Const declarations
+            if (line.startsWith('const ')) {
+                const constDecl = this.parseConstDeclaration(lines, i, filePath);
+                if (constDecl) {
+                    declarations.push(constDecl.node);
+                    i = constDecl.endIndex + 1;
+                    continue;
+                }
+            }
+            // Var declarations
+            if (line.startsWith('var ')) {
+                const varDecl = this.parseVarDeclaration(lines, i, filePath);
+                if (varDecl) {
+                    declarations.push(varDecl.node);
+                    i = varDecl.endIndex + 1;
+                    continue;
+                }
+            }
+            // Function declarations
+            if (line.match(/^func\s/)) {
+                const funcDecl = this.parseFunction(lines, i, filePath);
+                if (funcDecl) {
+                    declarations.push(funcDecl.node);
+                    i = funcDecl.endIndex + 1;
+                    continue;
+                }
+            }
+            i++;
+        }
+        return declarations;
+    }
+    parseTypeDeclaration(lines, startIdx, filePath) {
+        const line = lines[startIdx].trim();
+        const match = line.match(/type\s+(\w+)\s*(?:\[([^\]]*)\])?\s*(.+)/);
+        if (!match && !line.includes('type '))
+            return null;
+        const typeName = match?.[1] || line.match(/type\s+(\w+)/)?.[1];
+        if (!typeName)
+            return null;
+        let endIdx = startIdx;
+        let braceCount = 0;
+        // Check if it's a block type (struct, interface)
+        if (line.includes('{') || (!match?.[3] && lines[startIdx + 1]?.trim().startsWith('{'))) {
+            for (let i = startIdx; i < lines.length; i++) {
+                for (const char of lines[i]) {
+                    if (char === '{')
+                        braceCount++;
+                    if (char === '}')
+                        braceCount--;
+                }
+                if (braceCount === 0 && i > startIdx) {
+                    endIdx = i;
+                    break;
+                }
+            }
+        }
+        const body = lines.slice(startIdx, endIdx + 1).join('\n');
+        const isStruct = body.includes('struct {');
+        const isInterface = body.includes('interface {');
+        const isAlias = !isStruct && !isInterface && match?.[3];
+        const node = {
+            type: 'TypeDeclaration',
+            id: `${filePath}:${startIdx + 1}:0`,
+            location: this.createLocation(filePath, startIdx + 1, 0, endIdx + 1, lines[endIdx]?.length || 0),
+            children: [],
+            metadata: {
+                name: typeName,
+                isStruct,
+                isInterface,
+                isAlias,
+                underlyingType: isAlias ? match[3] : undefined,
+                fields: isStruct ? this.extractStructFields(body) : [],
+                methods: isInterface ? this.extractInterfaceMethods(body) : [],
+            },
+        };
+        return { node, endIndex: endIdx };
+    }
+    parseFunction(lines, startIdx, filePath) {
+        const line = lines[startIdx].trim();
+        // Match function signature
+        const sigMatch = line.match(/^func\s+(?:\(([^)]+)\)\s+)?(\w+)\s*\(([^)]*)\)\s*(\([^)]*\)|[^{]+)?/);
+        if (!sigMatch)
+            return null;
+        const receiver = sigMatch[1];
+        const funcName = sigMatch[2];
+        const params = sigMatch[3];
+        const returnType = sigMatch[4]?.trim();
+        // Find function body
+        let endIdx = startIdx;
+        let braceCount = 0;
+        let foundOpening = false;
+        for (let i = startIdx; i < lines.length; i++) {
+            for (const char of lines[i]) {
+                if (char === '{') {
+                    braceCount++;
+                    foundOpening = true;
+                }
+                if (char === '}')
+                    braceCount--;
+            }
+            if (foundOpening && braceCount === 0) {
+                endIdx = i;
+                break;
+            }
+        }
+        const body = lines.slice(startIdx, endIdx + 1).join('\n');
+        const statements = this.parseGoStatements(lines.slice(startIdx + 1, endIdx), filePath, startIdx + 1);
+        // Analyze concurrency patterns
+        const concurrency = this.analyzeConcurrency(body);
+        const node = {
+            type: 'FunctionDeclaration',
+            id: `${filePath}:${startIdx + 1}:0`,
+            location: this.createLocation(filePath, startIdx + 1, 0, endIdx + 1, lines[endIdx]?.length || 0),
+            children: statements,
+            metadata: {
+                name: funcName,
+                receiver: receiver ? this.parseReceiver(receiver) : undefined,
+                parameters: this.parseParameters(params),
+                returnType,
+                isMethod: !!receiver,
+                isExported: /^[A-Z]/.test(funcName),
+                hasDefer: body.includes('defer '),
+                hasPanic: body.includes('panic('),
+                hasRecover: body.includes('recover()'),
+                goroutines: concurrency.goroutines,
+                channels: concurrency.channels,
+                isConcurrent: concurrency.goroutines.length > 0,
+            },
+        };
+        return { node, endIndex: endIdx };
+    }
+    parseReceiver(receiver) {
+        const parts = receiver.trim().split(/\s+/);
+        if (parts.length === 2) {
+            return {
+                name: parts[0],
+                type: parts[1].replace('*', ''),
+                pointer: parts[1].startsWith('*'),
+            };
+        }
+        return { name: 'this', type: receiver.replace('*', ''), pointer: receiver.startsWith('*') };
+    }
+    parseParameters(params) {
+        const parameters = [];
+        if (!params.trim())
+            return parameters;
+        // Go allows grouped types: "a, b int"
+        const segments = this.splitParams(params);
+        for (const segment of segments) {
+            const trimmed = segment.trim();
+            if (!trimmed)
+                continue;
+            const parts = trimmed.split(/\s+/);
+            if (parts.length >= 2) {
+                const type = parts[parts.length - 1];
+                const isVariadic = type.startsWith('...');
+                // All names before the type share the same type
+                for (let i = 0; i < parts.length - 1; i++) {
+                    parameters.push({
+                        name: parts[i].replace(',', ''),
+                        type: type.replace(',', ''),
+                        variadic: isVariadic,
+                    });
+                }
+            }
+        }
+        return parameters;
+    }
+    parseConstDeclaration(lines, startIdx, filePath) {
+        const line = lines[startIdx].trim();
+        if (line.includes('(')) {
+            // Block const declaration
+            let endIdx = startIdx;
+            let parenCount = 0;
+            for (let i = startIdx; i < lines.length; i++) {
+                for (const char of lines[i]) {
+                    if (char === '(')
+                        parenCount++;
+                    if (char === ')')
+                        parenCount--;
+                }
+                if (parenCount === 0 && i > startIdx) {
+                    endIdx = i;
+                    break;
+                }
+            }
+            const blockContent = lines.slice(startIdx + 1, endIdx).join('\n');
+            const consts = this.extractConstsFromBlock(blockContent);
+            const node = {
+                type: 'ConstDeclaration',
+                id: `${filePath}:${startIdx + 1}:0`,
+                location: this.createLocation(filePath, startIdx + 1, 0, endIdx + 1, lines[endIdx]?.length || 0),
+                children: consts.map((c, idx) => ({
+                    type: 'ConstSpec',
+                    id: `${filePath}:${startIdx + 1 + idx}:0`,
+                    location: this.createLocation(filePath, startIdx + 1 + idx, 0, startIdx + 1 + idx, 0),
+                    children: [],
+                    metadata: c,
+                })),
+                metadata: { isBlock: true },
+            };
+            return { node, endIndex: endIdx };
+        }
+        else {
+            // Single const
+            const match = line.match(/const\s+(\w+)\s+(\w+)?\s*=\s*(.+)/);
+            if (match) {
+                const node = {
+                    type: 'ConstDeclaration',
+                    id: `${filePath}:${startIdx + 1}:0`,
+                    location: this.createLocation(filePath, startIdx + 1, 0, startIdx + 1, line.length),
+                    children: [],
+                    metadata: {
+                        name: match[1],
+                        type: match[2],
+                        value: match[3],
+                        isBlock: false,
+                    },
+                };
+                return { node, endIndex: startIdx };
+            }
+        }
+        return null;
+    }
+    parseVarDeclaration(lines, startIdx, filePath) {
+        const line = lines[startIdx].trim();
+        if (line.includes('(')) {
+            // Block var declaration
+            let endIdx = startIdx;
+            let parenCount = 0;
+            for (let i = startIdx; i < lines.length; i++) {
+                for (const char of lines[i]) {
+                    if (char === '(')
+                        parenCount++;
+                    if (char === ')')
+                        parenCount--;
+                }
+                if (parenCount === 0 && i > startIdx) {
+                    endIdx = i;
+                    break;
+                }
+            }
+            const blockContent = lines.slice(startIdx + 1, endIdx).join('\n');
+            const vars = this.extractVarsFromBlock(blockContent);
+            const node = {
+                type: 'VariableDeclaration',
+                id: `${filePath}:${startIdx + 1}:0`,
+                location: this.createLocation(filePath, startIdx + 1, 0, endIdx + 1, lines[endIdx]?.length || 0),
+                children: vars.map((v, idx) => ({
+                    type: 'VarSpec',
+                    id: `${filePath}:${startIdx + 1 + idx}:0`,
+                    location: this.createLocation(filePath, startIdx + 1 + idx, 0, startIdx + 1 + idx, 0),
+                    children: [],
+                    metadata: v,
+                })),
+                metadata: { isBlock: true },
+            };
+            return { node, endIndex: endIdx };
+        }
+        else {
+            // Single var or short declaration
+            const shortMatch = line.match(/^(\w+)\s*:=\s*(.+)/);
+            if (shortMatch) {
+                const node = {
+                    type: 'ShortVariableDeclaration',
+                    id: `${filePath}:${startIdx + 1}:0`,
+                    location: this.createLocation(filePath, startIdx + 1, 0, startIdx + 1, line.length),
+                    children: [],
+                    metadata: {
+                        name: shortMatch[1],
+                        initializer: shortMatch[2],
+                        inferred: true,
+                    },
+                };
+                return { node, endIndex: startIdx };
+            }
+            const varMatch = line.match(/var\s+(\w+)\s+(\w+)?\s*(?:=\s*(.+))?/);
+            if (varMatch) {
+                const node = {
+                    type: 'VariableDeclaration',
+                    id: `${filePath}:${startIdx + 1}:0`,
+                    location: this.createLocation(filePath, startIdx + 1, 0, startIdx + 1, line.length),
+                    children: [],
+                    metadata: {
+                        name: varMatch[1],
+                        type: varMatch[2],
+                        initializer: varMatch[3],
+                        isBlock: false,
+                    },
+                };
+                return { node, endIndex: startIdx };
+            }
+        }
+        return null;
+    }
+    parseGoStatements(lines, filePath, lineOffset) {
+        const statements = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            // Goroutine spawn
+            if (line.startsWith('go ')) {
+                statements.push({
+                    type: 'GoStatement',
+                    id: `${filePath}:${lineOffset + i + 1}:0`,
+                    location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                    children: [],
+                    metadata: {
+                        call: line.substring(3).trim(),
+                    },
+                });
+            }
+            // Channel operations
+            if (line.includes('<-') || line.includes('chan ')) {
+                const isSend = line.match(/([^<]+)\s*<-\s*(.+)/);
+                const isRecv = line.match(/<-\s*(.+)/);
+                if (isSend || isRecv) {
+                    statements.push({
+                        type: 'ChannelOperation',
+                        id: `${filePath}:${lineOffset + i + 1}:0`,
+                        location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                        children: [],
+                        metadata: {
+                            isSend: !!isSend,
+                            isRecv: !!isRecv,
+                            channel: isSend?.[1]?.trim() || 'unknown',
+                            value: isSend?.[2]?.trim() || isRecv?.[1]?.trim(),
+                        },
+                    });
+                }
+            }
+            // Select statement
+            if (line.startsWith('select {')) {
+                statements.push({
+                    type: 'SelectStatement',
+                    id: `${filePath}:${lineOffset + i + 1}:0`,
+                    location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                    children: [],
+                    metadata: {},
+                });
+            }
+            // Defer
+            if (line.startsWith('defer ')) {
+                statements.push({
+                    type: 'DeferStatement',
+                    id: `${filePath}:${lineOffset + i + 1}:0`,
+                    location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                    children: [],
+                    metadata: {
+                        call: line.substring(6).trim(),
+                    },
+                });
+            }
+            // Panic/Recover
+            if (line.includes('panic(')) {
+                statements.push({
+                    type: 'PanicStatement',
+                    id: `${filePath}:${lineOffset + i + 1}:0`,
+                    location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                    children: [],
+                    metadata: {},
+                });
+            }
+            // Range statement
+            if (line.startsWith('for ') && line.includes(' range ')) {
+                statements.push({
+                    type: 'RangeStatement',
+                    id: `${filePath}:${lineOffset + i + 1}:0`,
+                    location: this.createLocation(filePath, lineOffset + i + 1, 0, lineOffset + i + 1, line.length),
+                    children: [],
+                    metadata: {},
+                });
+            }
+        }
+        return statements;
+    }
+    analyzeConcurrency(body) {
+        const goroutines = [];
+        const channels = [];
+        // Find goroutine spawns
+        const goRegex = /go\s+(\w+)\s*\(/g;
+        let match;
+        while ((match = goRegex.exec(body)) !== null) {
+            goroutines.push(match[1]);
+        }
+        // Find channel operations
+        const chanRegex = /make\(chan\s+(\w+)/g;
+        while ((match = chanRegex.exec(body)) !== null) {
+            channels.push(match[1]);
+        }
+        return { goroutines, channels };
+    }
+    extractStructFields(body) {
+        const fields = [];
+        const fieldRegex = /(\w+)\s+(\S+)(?:\s+`([^`]+)`)?/g;
+        let match;
+        while ((match = fieldRegex.exec(body)) !== null) {
+            fields.push({
+                name: match[1],
+                type: match[2],
+                tag: match[3],
+            });
+        }
+        return fields;
+    }
+    extractInterfaceMethods(body) {
+        const methods = [];
+        const methodRegex = /(\w+)\s*\(([^)]*)\)\s*(\([^)]*\)|\w+)?/g;
+        let match;
+        while ((match = methodRegex.exec(body)) !== null) {
+            methods.push({
+                name: match[1],
+                signature: match[0],
+            });
+        }
+        return methods;
+    }
+    extractConstsFromBlock(content) {
+        const consts = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//'))
+                continue;
+            const match = trimmed.match(/(\w+)\s+(\w+)?\s*=\s*(.+)/);
+            if (match) {
+                consts.push({
+                    name: match[1],
+                    type: match[2],
+                    value: match[3].replace(/,$/, ''),
+                });
+            }
+        }
+        return consts;
+    }
+    extractVarsFromBlock(content) {
+        const vars = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//'))
+                continue;
+            const match = trimmed.match(/(\w+)\s+(\w+)?\s*(?:=\s*(.+))?/);
+            if (match) {
+                vars.push({
+                    name: match[1],
+                    type: match[2],
+                    value: match[3]?.replace(/,$/, ''),
+                });
+            }
+        }
+        return vars;
+    }
+    splitParams(params) {
+        const result = [];
+        let current = '';
+        let depth = 0;
+        for (const char of params) {
+            if (char === '(' || char === '[' || char === '<')
+                depth++;
+            if (char === ')' || char === ']' || char === '>')
+                depth--;
+            if (char === ',' && depth === 0) {
+                result.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            result.push(current.trim());
+        }
+        return result;
+    }
+    findMatchingParen(source, startIdx) {
+        let depth = 1;
+        for (let i = startIdx + 1; i < source.length; i++) {
+            if (source[i] === '(')
+                depth++;
+            if (source[i] === ')')
+                depth--;
+            if (depth === 0)
+                return i;
+        }
+        return source.length - 1;
+    }
+    findSyntaxErrors() {
+        const errors = [];
+        let braceCount = 0;
+        let parenCount = 0;
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            // Skip comments and strings
+            let inString = false;
+            let stringChar = '';
+            let escaped = false;
+            for (const char of line) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escaped = true;
+                    continue;
+                }
+                if (!inString && (char === '"' || char === "'" || char === '`')) {
+                    inString = true;
+                    stringChar = char;
+                    continue;
+                }
+                if (inString && char === stringChar) {
+                    inString = false;
+                    continue;
+                }
+                if (!inString) {
+                    if (char === '{')
+                        braceCount++;
+                    if (char === '}')
+                        braceCount--;
+                    if (char === '(')
+                        parenCount++;
+                    if (char === ')')
+                        parenCount--;
+                }
+            }
+            if (braceCount < 0) {
+                errors.push({ message: 'Unexpected }', line: i + 1, severity: 'error' });
+                braceCount = 0;
+            }
+            if (parenCount < 0) {
+                errors.push({ message: 'Unexpected )', line: i + 1, severity: 'error' });
+                parenCount = 0;
+            }
+        }
+        if (braceCount > 0) {
+            errors.push({ message: `Missing ${braceCount} closing brace(s)`, line: this.lines.length, severity: 'error' });
+        }
+        if (parenCount > 0) {
+            errors.push({ message: `Missing ${parenCount} closing paren(s)`, line: this.lines.length, severity: 'error' });
+        }
+        return errors;
+    }
+    extractComments() {
+        const comments = [];
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            const commentIdx = line.indexOf('//');
+            if (commentIdx !== -1) {
+                comments.push({
+                    type: 'Line',
+                    value: line.substring(commentIdx + 2).trim(),
+                    line: i + 1,
+                });
+            }
+        }
+        // Block comments /* */
+        const blockRegex = /\/\*[\s\S]*?\*\//g;
+        let match;
+        while ((match = blockRegex.exec(this.source)) !== null) {
+            const lineNum = this.source.substring(0, match.index).split('\n').length;
+            comments.push({
+                type: 'Block',
+                value: match[0].substring(2, match[0].length - 2).trim(),
+                line: lineNum,
+            });
+        }
+        return comments;
+    }
+    createLocation(file, startLine, startCol, endLine, endCol) {
+        return {
+            file,
+            startLine,
+            startColumn: startCol,
+            endLine,
+            endColumn: endCol,
+            byteOffset: 0,
+        };
+    }
+    fallbackParse(filePath) {
+        return {
+            ast: this.parseGo(this.source, filePath),
+            errors: this.findSyntaxErrors(),
+            warnings: [{ message: 'Using fallback parser' }],
+            tokens: [],
+            comments: this.extractComments(),
+        };
+    }
+}
+exports.GoParser = GoParser;
+class GoAnalyzer {
+    analyze(ast, context) {
+        const symbolTable = this.buildSymbolTable(ast);
+        const concurrencyAnalysis = this.analyzeConcurrency(ast);
+        const errorAnalysis = this.analyzeErrorHandling(ast);
+        return {
+            symbols: symbolTable,
+            callGraph: this.buildCallGraph(ast),
+            dataFlow: this.buildDataFlow(ast),
+            controlFlow: this.buildControlFlow(ast),
+            typeInference: new Map(),
+            metrics: this.calculateMetrics(ast),
+            suggestions: [
+                ...concurrencyAnalysis.suggestions,
+                ...errorAnalysis.suggestions,
+            ],
+        };
+    }
+    buildSymbolTable(ast) {
+        return {
+            variables: new Map(),
+            functions: new Map(),
+            classes: new Map(),
+            modules: new Map(),
+            imports: [],
+            exports: [],
+        };
+    }
+    analyzeConcurrency(ast) {
+        const suggestions = [];
+        let goroutineCount = 0;
+        let channelCount = 0;
+        let selectCount = 0;
+        const traverse = (node) => {
+            if (node.type === 'GoStatement')
+                goroutineCount++;
+            if (node.type === 'ChannelOperation')
+                channelCount++;
+            if (node.type === 'SelectStatement')
+                selectCount++;
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        if (goroutineCount > 0 && channelCount === 0) {
+            suggestions.push({
+                type: 'concurrency',
+                severity: 'warning',
+                message: `Spawning ${goroutineCount} goroutines without explicit synchronization`,
+                remediation: 'Use channels or sync.WaitGroup for coordination',
+            });
+        }
+        if (goroutineCount > 10) {
+            suggestions.push({
+                type: 'performance',
+                severity: 'info',
+                message: 'High number of goroutines - consider using worker pools',
+                remediation: 'Use a bounded worker pool pattern',
+            });
+        }
+        return { suggestions };
+    }
+    analyzeErrorHandling(ast) {
+        const suggestions = [];
+        let panicCount = 0;
+        let recoverCount = 0;
+        const traverse = (node) => {
+            if (node.type === 'PanicStatement')
+                panicCount++;
+            if (node.metadata?.hasRecover)
+                recoverCount++;
+            node.children.forEach(traverse);
+        };
+        traverse(ast);
+        if (panicCount > 0 && recoverCount === 0) {
+            suggestions.push({
+                type: 'error-handling',
+                severity: 'warning',
+                message: `Using ${panicCount} panic(s) without recover`,
+                remediation: 'Add defer/recover or return errors instead',
+            });
+        }
+        return { suggestions };
+    }
+    buildCallGraph(ast) {
+        return { nodes: [], edges: [], entryPoints: [], deadCode: [] };
+    }
+    buildDataFlow(ast) {
+        return { definitions: new Map(), uses: new Map(), taintedSources: [], sinks: [] };
+    }
+    buildControlFlow(ast) {
+        return { nodes: [], edges: [], loops: [], branches: [] };
+    }
+    calculateMetrics(ast) {
+        return {
+            linesOfCode: 0,
+            logicalLines: 0,
+            commentLines: 0,
+            blankLines: 0,
+            cyclomaticComplexity: 0,
+            cognitiveComplexity: 0,
+            halsteadMetrics: { operators: 0, operands: 0, uniqueOperators: 0, uniqueOperands: 0, volume: 0, difficulty: 0, effort: 0, timeToProgram: 0, bugsDelivered: 0 },
+            maintainabilityIndex: 0,
+            duplicateRate: 0,
+        };
+    }
+}
+exports.GoAnalyzer = GoAnalyzer;
+exports.GoLanguageSupport = {
+    id: 'go',
+    name: 'Go',
+    extensions: ['.go'],
+    parser: new GoParser(),
+    analyzer: new GoAnalyzer(),
+};
+//# sourceMappingURL=go.js.map