VS Code 扩展开发阶段五：语言扩展开发 - 语法高亮、智能感知与LSP

// src/semanticTokensProvider.ts
import * as vscode from 'vscode';

export class MyLangSemanticTokensProvider implements vscode.DocumentSemanticTokensProvider {
    
    // 定义语义token类型和修饰符
    private readonly legend: vscode.SemanticTokensLegend = new vscode.SemanticTokensLegend(
        [
            'namespace', 'type', 'class', 'enum', 'interface', 'struct',
            'typeParameter', 'parameter', 'variable', 'property', 'enumMember',
            'event', 'function', 'method', 'macro', 'keyword', 'modifier',
            'comment', 'string', 'number', 'regexp', 'operator'
        ],
        [
            'declaration', 'definition', 'readonly', 'static', 'deprecated',
            'abstract', 'async', 'modification', 'documentation', 'defaultLibrary'
        ]
    );
    
    async provideDocumentSemanticTokens(
        document: vscode.TextDocument,
        token: vscode.CancellationToken
    ): Promise<vscode.SemanticTokens> {
        
        const tokensBuilder = new vscode.SemanticTokensBuilder(this.legend);
        const text = document.getText();
        
        // 解析文档并生成语义tokens
        await this.parseDocument(document, tokensBuilder);
        
        return tokensBuilder.build();
    }
    
    private async parseDocument(
        document: vscode.TextDocument,
        builder: vscode.SemanticTokensBuilder
    ): Promise<void> {
        
        const text = document.getText();
        const lines = text.split('\n');
        
        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
            const line = lines[lineIndex];
            
            // 解析函数定义
            const functionMatch = /function\s+(\w+)\s*\(/g;
            let match;
            while ((match = functionMatch.exec(line)) !== null) {
                const startPos = match.index + match[0].indexOf(match[1]);
                builder.push(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + match[1].length),
                    'function',
                    ['declaration']
                );
            }
            
            // 解析变量声明
            const variableMatch = /(var|let|const)\s+(\w+)/g;
            while ((match = variableMatch.exec(line)) !== null) {
                const startPos = match.index + match[0].indexOf(match[2]);
                builder.push(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + match[2].length),
                    'variable',
                    ['declaration']
                );
            }
            
            // 解析类型声明
            const typeMatch = /(class|interface|enum)\s+(\w+)/g;
            while ((match = typeMatch.exec(line)) !== null) {
                const startPos = match.index + match[0].indexOf(match[2]);
                const tokenType = match[1] === 'class' ? 'class' : 
                                match[1] === 'interface' ? 'interface' : 'enum';
                builder.push(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + match[2].length),
                    tokenType,
                    ['declaration']
                );
            }
            
            // 解析字符串字面量中的变量插值
            const interpolationMatch = /\$\{(\w+)\}/g;
            while ((match = interpolationMatch.exec(line)) !== null) {
                const startPos = match.index + 2; // 跳过 ${
                builder.push(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + match[1].length),
                    'variable',
                    ['readonly']
                );
            }
            
            // 解析注释中的TODO、FIXME等
            const commentTodoMatch = /\/\/.*?(TODO|FIXME|NOTE|HACK):/g;
            while ((match = commentTodoMatch.exec(line)) !== null) {
                const startPos = match.index + match[0].indexOf(match[1]);
                builder.push(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + match[1].length),
                    'keyword',
                    ['documentation']
                );
            }
        }
    }
    
    // 增量更新支持
    async provideDocumentSemanticTokensEdits(
        document: vscode.TextDocument,
        previousResultId: string,
        token: vscode.CancellationToken
    ): Promise<vscode.SemanticTokens | vscode.SemanticTokensEdits> {
        
        // 对于简单情况，直接返回新的tokens
        // 复杂的增量更新需要实现差异检测
        return this.provideDocumentSemanticTokens(document, token);
    }
    
    getLegend(): vscode.SemanticTokensLegend {
        return this.legend;
    }
}

// src/completionProvider.ts
import * as vscode from 'vscode';

export class MyLangCompletionProvider implements vscode.CompletionItemProvider {
    
    private keywords = [
        'function', 'var', 'let', 'const', 'if', 'else', 'while', 'for',
        'return', 'break', 'continue', 'class', 'interface', 'enum',
        'import', 'export', 'async', 'await', 'try', 'catch', 'finally'
    ];
    
    private builtinTypes = [
        'string', 'number', 'boolean', 'object', 'array', 'void', 'any'
    ];
    
    async provideCompletionItems(
        document: vscode.TextDocument,
        position: vscode.Position,
        token: vscode.CancellationToken,
        context: vscode.CompletionContext
    ): Promise<vscode.CompletionItem[]> {
        
        const lineText = document.lineAt(position).text;
        const wordRange = document.getWordRangeAtPosition(position);
        const currentWord = wordRange ? document.getText(wordRange) : '';
        
        const completions: vscode.CompletionItem[] = [];
        
        // 根据上下文提供不同的补全
        if (this.isInStringContext(lineText, position.character)) {
            // 字符串内的补全
            completions.push(...this.getStringCompletions());
        } else if (this.isInCommentContext(lineText, position.character)) {
            // 注释内的补全
            completions.push(...this.getCommentCompletions());
        } else {
            // 普通代码补全
            completions.push(
                ...this.getKeywordCompletions(),
                ...this.getTypeCompletions(),
                ...this.getFunctionCompletions(document, position),
                ...this.getVariableCompletions(document, position),
                ...this.getSnippetCompletions()
            );
        }
        
        return completions.filter(item => 
            !currentWord || item.label.toString().toLowerCase().includes(currentWord.toLowerCase())
        );
    }
    
    private getKeywordCompletions(): vscode.CompletionItem[] {
        return this.keywords.map(keyword => {
            const item = new vscode.CompletionItem(keyword, vscode.CompletionItemKind.Keyword);
            item.detail = `关键字 ${keyword}`;
            item.documentation = new vscode.MarkdownString(`MyLang关键字 \`${keyword}\``);
            
            // 为某些关键字添加代码片段
            switch (keyword) {
                case 'function':
                    item.insertText = new vscode.SnippetString('function ${1:name}(${2:params}) {\n\t$0\n}');
                    break;
                case 'if':
                    item.insertText = new vscode.SnippetString('if (${1:condition}) {\n\t$0\n}');
                    break;
                case 'for':
                    item.insertText = new vscode.SnippetString('for (let ${1:i} = 0; ${1:i} < ${2:length}; ${1:i}++) {\n\t$0\n}');
                    break;
                case 'class':
                    item.insertText = new vscode.SnippetString('class ${1:ClassName} {\n\tconstructor(${2:params}) {\n\t\t$0\n\t}\n}');
                    break;
            }
            
            return item;
        });
    }
    
    private getTypeCompletions(): vscode.CompletionItem[] {
        return this.builtinTypes.map(type => {
            const item = new vscode.CompletionItem(type, vscode.CompletionItemKind.TypeParameter);
            item.detail = `内置类型 ${type}`;
            item.documentation = new vscode.MarkdownString(`MyLang内置类型 \`${type}\``);
            return item;
        });
    }
    
    private getFunctionCompletions(
        document: vscode.TextDocument,
        position: vscode.Position
    ): vscode.CompletionItem[] {
        const functions: vscode.CompletionItem[] = [];
        const text = document.getText();
        
        // 解析文档中的函数定义
        const functionRegex = /function\s+(\w+)\s*\(([^)]*)\)/g;
        let match;
        
        while ((match = functionRegex.exec(text)) !== null) {
            const [, functionName, params] = match;
            
            const item = new vscode.CompletionItem(functionName, vscode.CompletionItemKind.Function);
            item.detail = `function ${functionName}(${params})`;
            item.documentation = new vscode.MarkdownString(`用户定义的函数\n\n\`\`\`mylang\nfunction ${functionName}(${params})\n\`\`\``);
            
            // 添加参数提示
            const paramList = params.split(',').map((p, i) => `\${${i + 1}:${p.trim()}}`).join(', ');
            item.insertText = new vscode.SnippetString(`${functionName}(${paramList})`);
            
            functions.push(item);
        }
        
        // 添加内置函数
        const builtinFunctions = [
            {
                name: 'console.log',
                params: 'message',
                description: '在控制台输出消息'
            },
            {
                name: 'Math.abs',
                params: 'x',
                description: '返回数字的绝对值'
            },
            {
                name: 'String.prototype.charAt',
                params: 'index',
                description: '返回指定位置的字符'
            }
        ];
        
        builtinFunctions.forEach(func => {
            const item = new vscode.CompletionItem(func.name, vscode.CompletionItemKind.Function);
            item.detail = `${func.name}(${func.params})`;
            item.documentation = new vscode.MarkdownString(func.description);
            item.insertText = new vscode.SnippetString(`${func.name}(\${1:${func.params}})`);
            functions.push(item);
        });
        
        return functions;
    }
    
    private getVariableCompletions(
        document: vscode.TextDocument,
        position: vscode.Position
    ): vscode.CompletionItem[] {
        const variables: vscode.CompletionItem[] = [];
        const text = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
        
        // 解析变量声明
        const variableRegex = /(var|let|const)\s+(\w+)/g;
        let match;
        
        while ((match = variableRegex.exec(text)) !== null) {
            const [, type, variableName] = match;
            
            const item = new vscode.CompletionItem(variableName, vscode.CompletionItemKind.Variable);
            item.detail = `${type} ${variableName}`;
            item.documentation = new vscode.MarkdownString(`变量声明：\`${type} ${variableName}\``);
            
            variables.push(item);
        }
        
        return variables;
    }
    
    private getSnippetCompletions(): vscode.CompletionItem[] {
        const snippets = [
            {
                label: 'log',
                detail: 'console.log语句',
                snippet: 'console.log(${1:message});'
            },
            {
                label: 'func',
                detail: '函数声明',
                snippet: 'function ${1:name}(${2:params}) {\n\t${3:// body}\n\treturn ${4:undefined};\n}'
            },
            {
                label: 'tryc',
                detail: 'try-catch语句',
                snippet: 'try {\n\t${1:// try body}\n} catch (${2:error}) {\n\t${3:// catch body}\n}'
            }
        ];
        
        return snippets.map(snippet => {
            const item = new vscode.CompletionItem(snippet.label, vscode.CompletionItemKind.Snippet);
            item.detail = snippet.detail;
            item.insertText = new vscode.SnippetString(snippet.snippet);
            item.documentation = new vscode.MarkdownString(`代码片段：${snippet.detail}`);
            return item;
        });
    }
    
    private getStringCompletions(): vscode.CompletionItem[] {
        // 字符串内的特殊补全（如模板字符串变量）
        return [
            new vscode.CompletionItem('${variable}', vscode.CompletionItemKind.Text)
        ];
    }
    
    private getCommentCompletions(): vscode.CompletionItem[] {
        // 注释内的补全（如TODO、FIXME）
        const commentKeywords = ['TODO', 'FIXME', 'NOTE', 'HACK', 'XXX'];
        return commentKeywords.map(keyword => {
            const item = new vscode.CompletionItem(keyword, vscode.CompletionItemKind.Keyword);
            item.detail = `注释关键字 ${keyword}`;
            return item;
        });
    }
    
    private isInStringContext(lineText: string, position: number): boolean {
        const beforeCursor = lineText.substring(0, position);
        const quoteCount = (beforeCursor.match(/"/g) || []).length;
        return quoteCount % 2 === 1;
    }
    
    private isInCommentContext(lineText: string, position: number): boolean {
        const beforeCursor = lineText.substring(0, position);
        return beforeCursor.includes('//') || beforeCursor.includes('/*');
    }
    
    resolveCompletionItem(
        item: vscode.CompletionItem,
        token: vscode.CancellationToken
    ): vscode.ProviderResult<vscode.CompletionItem> {
        
        // 为补全项添加更详细的信息
        if (item.kind === vscode.CompletionItemKind.Function) {
            item.documentation = new vscode.MarkdownString(
                `函数：${item.label}\n\n` +
                `**详细信息：**\n` +
                `- 参数：${item.detail}\n` +
                `- 返回值：根据实现而定\n\n` +
                `**示例：**\n` +
                `\`\`\`mylang\n${item.label}(参数)\n\`\`\``
            );
        }
        
        return item;
    }
}

// src/hoverProvider.ts
import * as vscode from 'vscode';

export class MyLangHoverProvider implements vscode.HoverProvider {
    
    async provideHover(
        document: vscode.TextDocument,
        position: vscode.Position,
        token: vscode.CancellationToken
    ): Promise<vscode.Hover | undefined> {
        
        const wordRange = document.getWordRangeAtPosition(position);
        if (!wordRange) {
            return undefined;
        }
        
        const word = document.getText(wordRange);
        const line = document.lineAt(position.line).text;
        
        // 获取悬停信息
        const hoverInfo = await this.getHoverInfo(document, word, position, line);
        
        if (hoverInfo) {
            return new vscode.Hover(hoverInfo, wordRange);
        }
        
        return undefined;
    }
    
    private async getHoverInfo(
        document: vscode.TextDocument,
        word: string,
        position: vscode.Position,
        line: string
    ): Promise<vscode.MarkdownString | undefined> {
        
        // 检查是否是关键字
        if (this.isKeyword(word)) {
            return this.getKeywordHover(word);
        }
        
        // 检查是否是函数调用
        if (this.isFunctionCall(line, word)) {
            return this.getFunctionHover(document, word);
        }
        
        // 检查是否是变量
        if (this.isVariable(document, word, position)) {
            return this.getVariableHover(document, word, position);
        }
        
        // 检查是否是类型
        if (this.isType(word)) {
            return this.getTypeHover(word);
        }
        
        // 检查是否是内置函数或对象
        if (this.isBuiltinFunction(word)) {
            return this.getBuiltinFunctionHover(word);
        }
        
        return undefined;
    }
    
    private isKeyword(word: string): boolean {
        const keywords = [
            'function', 'var', 'let', 'const', 'if', 'else', 'while', 'for',
            'return', 'break', 'continue', 'class', 'interface', 'enum',
            'import', 'export', 'async', 'await', 'try', 'catch', 'finally'
        ];
        return keywords.includes(word);
    }
    
    private getKeywordHover(keyword: string): vscode.MarkdownString {
        const descriptions: Record<string, string> = {
            'function': '用于声明函数的关键字',
            'var': '声明变量（函数作用域）',
            'let': '声明变量（块作用域）',
            'const': '声明常量（块作用域）',
            'if': '条件语句',
            'else': '条件语句的否则分支',
            'while': '循环语句',
            'for': '循环语句',
            'return': '函数返回语句',
            'break': '跳出循环或switch语句',
            'continue': '跳过当前循环迭代',
            'class': '声明类',
            'interface': '声明接口',
            'enum': '声明枚举',
            'import': '导入模块',
            'export': '导出模块成员',
            'async': '声明异步函数',
            'await': '等待异步操作完成',
            'try': '异常处理语句',
            'catch': '捕获异常',
            'finally': '异常处理的最终执行块'
        };
        
        const description = descriptions[keyword] || '关键字';
        
        const markdown = new vscode.MarkdownString();
        markdown.appendCodeblock(`${keyword}`, 'mylang');
        markdown.appendMarkdown(`**关键字：** ${keyword}\n\n`);
        markdown.appendMarkdown(`**描述：** ${description}\n\n`);
        
        // 添加使用示例
        const examples: Record<string, string> = {
            'function': 'function myFunction(param1, param2) {\n    return param1 + param2;\n}',
            'if': 'if (condition) {\n    // 执行代码\n}',
            'for': 'for (let i = 0; i < 10; i++) {\n    // 循环体\n}',
            'class': 'class MyClass {\n    constructor() {\n        // 构造函数\n    }\n}'
        };
        
        if (examples[keyword]) {
            markdown.appendMarkdown(`**示例：**\n`);
            markdown.appendCodeblock(examples[keyword], 'mylang');
        }
        
        return markdown;
    }
    
    private isFunctionCall(line: string, word: string): boolean {
        const functionCallPattern = new RegExp(`\\b${word}\\s*\\(`);
        return functionCallPattern.test(line);
    }
    
    private getFunctionHover(document: vscode.TextDocument, functionName: string): vscode.MarkdownString {
        const text = document.getText();
        
        // 查找函数定义
        const functionDefPattern = new RegExp(`function\\s+${functionName}\\s*\\(([^)]*)\\)\\s*\\{`, 'g');
        const match = functionDefPattern.exec(text);
        
        const markdown = new vscode.MarkdownString();
        
        if (match) {
            const params = match[1];
            markdown.appendCodeblock(`function ${functionName}(${params})`, 'mylang');
            markdown.appendMarkdown(`**函数：** ${functionName}\n\n`);
            markdown.appendMarkdown(`**参数：** ${params || '无'}\n\n`);
            
            // 尝试提取函数注释
            const functionComment = this.extractFunctionComment(text, match.index);
            if (functionComment) {
                markdown.appendMarkdown(`**描述：** ${functionComment}\n\n`);
            }
        } else {
            // 检查是否是内置函数
            const builtinInfo = this.getBuiltinFunctionInfo(functionName);
            if (builtinInfo) {
                markdown.appendCodeblock(`${functionName}(${builtinInfo.params})`, 'mylang');
                markdown.appendMarkdown(`**内置函数：** ${functionName}\n\n`);
                markdown.appendMarkdown(`**描述：** ${builtinInfo.description}\n\n`);
                markdown.appendMarkdown(`**返回值：** ${builtinInfo.returnType}\n\n`);
            } else {
                markdown.appendCodeblock(functionName, 'mylang');
                markdown.appendMarkdown(`**函数：** ${functionName}\n\n`);
                markdown.appendMarkdown(`*未找到函数定义*`);
            }
        }
        
        return markdown;
    }
    
    private isVariable(document: vscode.TextDocument, word: string, position: vscode.Position): boolean {
        const text = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
        const variablePattern = new RegExp(`\\b(var|let|const)\\s+${word}\\b`);
        return variablePattern.test(text);
    }
    
    private getVariableHover(
        document: vscode.TextDocument,
        variableName: string,
        position: vscode.Position
    ): vscode.MarkdownString {
        
        const text = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
        
        // 查找变量声明
        const variablePattern = new RegExp(`\\b(var|let|const)\\s+${variableName}(\\s*=\\s*([^;\\n]+))?`, 'g');
        const matches = Array.from(text.matchAll(variablePattern));
        
        const markdown = new vscode.MarkdownString();
        
        if (matches.length > 0) {
            const lastMatch = matches[matches.length - 1];
            const [, declarationType, , initialValue] = lastMatch;
            
            markdown.appendCodeblock(`${declarationType} ${variableName}${initialValue ? ` = ${initialValue}` : ''}`, 'mylang');
            markdown.appendMarkdown(`**变量：** ${variableName}\n\n`);
            markdown.appendMarkdown(`**类型：** ${declarationType}\n\n`);
            
            if (initialValue) {
                markdown.appendMarkdown(`**初始值：** ${initialValue.trim()}\n\n`);
                
                // 尝试推断类型
                const inferredType = this.inferType(initialValue.trim());
                if (inferredType) {
                    markdown.appendMarkdown(`**推断类型：** ${inferredType}\n\n`);
                }
            }
        } else {
            markdown.appendCodeblock(variableName, 'mylang');
            markdown.appendMarkdown(`**变量：** ${variableName}\n\n`);
            markdown.appendMarkdown(`*未找到变量声明*`);
        }
        
        return markdown;
    }
    
    private isType(word: string): boolean {
        const types = ['string', 'number', 'boolean', 'object', 'array', 'void', 'any'];
        return types.includes(word);
    }
    
    private getTypeHover(typeName: string): vscode.MarkdownString {
        const typeDescriptions: Record<string, string> = {
            'string': '字符串类型 - 表示文本数据',
            'number': '数字类型 - 表示整数或浮点数',
            'boolean': '布尔类型 - 表示true或false',
            'object': '对象类型 - 表示复合数据结构',
            'array': '数组类型 - 表示有序的元素集合',
            'void': 'void类型 - 表示无返回值',
            'any': 'any类型 - 表示任意类型'
        };
        
        const markdown = new vscode.MarkdownString();
        markdown.appendCodeblock(typeName, 'mylang');
        markdown.appendMarkdown(`**类型：** ${typeName}\n\n`);
        markdown.appendMarkdown(`**描述：** ${typeDescriptions[typeName]}\n\n`);
        
        return markdown;
    }
    
    private isBuiltinFunction(word: string): boolean {
        const builtinFunctions = ['console', 'Math', 'String', 'Array', 'Object', 'Date'];
        return builtinFunctions.some(builtin => word.startsWith(builtin));
    }
    
    private getBuiltinFunctionHover(word: string): vscode.MarkdownString {
        const builtinInfo = this.getBuiltinFunctionInfo(word);
        
        const markdown = new vscode.MarkdownString();
        markdown.appendCodeblock(word, 'mylang');
        markdown.appendMarkdown(`**内置对象/方法：** ${word}\n\n`);
        
        if (builtinInfo) {
            markdown.appendMarkdown(`**描述：** ${builtinInfo.description}\n\n`);
            if (builtinInfo.params) {
                markdown.appendMarkdown(`**参数：** ${builtinInfo.params}\n\n`);
            }
            if (builtinInfo.returnType) {
                markdown.appendMarkdown(`**返回值：** ${builtinInfo.returnType}\n\n`);
            }
        }
        
        return markdown;
    }
    
    private getBuiltinFunctionInfo(name: string): {
        description: string;
        params?: string;
        returnType?: string;
    } | undefined {
        
        const builtins: Record<string, any> = {
            'console.log': {
                description: '在控制台输出信息',
                params: 'message: any',
                returnType: 'void'
            },
            'Math.abs': {
                description: '返回数字的绝对值',
                params: 'x: number',
                returnType: 'number'
            },
            'Math.max': {
                description: '返回最大值',
                params: '...values: number[]',
                returnType: 'number'
            },
            'String.prototype.charAt': {
                description: '返回指定位置的字符',
                params: 'index: number',
                returnType: 'string'
            },
            'Array.prototype.push': {
                description: '向数组末尾添加元素',
                params: '...items: any[]',
                returnType: 'number'
            }
        };
        
        return builtins[name];
    }
    
    private extractFunctionComment(text: string, functionIndex: number): string | undefined {
        // 向前查找注释
        const beforeFunction = text.substring(0, functionIndex);
        const lines = beforeFunction.split('\n');
        
        // 从函数定义行往前查找注释
        for (let i = lines.length - 1; i >= 0; i--) {
            const line = lines[i].trim();
            
            if (line.startsWith('//')) {
                return line.substring(2).trim();
            } else if (line.includes('/*') && line.includes('*/')) {
                const commentMatch = line.match(/\/\*(.*?)\*\//);
                if (commentMatch) {
                    return commentMatch[1].trim();
                }
            } else if (line && !line.startsWith('//') && !line.includes('/*')) {
                // 如果遇到非注释的非空行，停止查找
                break;
            }
        }
        
        return undefined;
    }
    
    private inferType(value: string): string | undefined {
        value = value.trim();
        
        if (value.startsWith('"') && value.endsWith('"')) {
            return 'string';
        }
        
        if (value.startsWith("'") && value.endsWith("'")) {
            return 'string';
        }
        
        if (/^\d+$/.test(value)) {
            return 'number';
        }
        
        if (/^\d+\.\d+$/.test(value)) {
            return 'number';
        }
        
        if (value === 'true' || value === 'false') {
            return 'boolean';
        }
        
        if (value.startsWith('[') && value.endsWith(']')) {
            return 'array';
        }
        
        if (value.startsWith('{') && value.endsWith('}')) {
            return 'object';
        }
        
        return undefined;
    }
}

// src/diagnosticProvider.ts
import * as vscode from 'vscode';

export class MyLangDiagnosticProvider {
    private diagnosticCollection: vscode.DiagnosticCollection;
    
    constructor() {
        this.diagnosticCollection = vscode.languages.createDiagnosticCollection('mylang');
    }
    
    async provideDiagnostics(document: vscode.TextDocument): Promise<void> {
        const diagnostics: vscode.Diagnostic[] = [];
        const text = document.getText();
        const lines = text.split('\n');
        
        for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
            const line = lines[lineIndex];
            
            // 检查语法错误
            diagnostics.push(...this.checkSyntaxErrors(line, lineIndex));
            
            // 检查未使用的变量
            diagnostics.push(...this.checkUnusedVariables(document, lineIndex));
            
            // 检查类型错误
            diagnostics.push(...this.checkTypeErrors(line, lineIndex));
            
            // 检查代码风格问题
            diagnostics.push(...this.checkStyleIssues(line, lineIndex));
            
            // 检查最佳实践
            diagnostics.push(...this.checkBestPractices(line, lineIndex));
        }
        
        this.diagnosticCollection.set(document.uri, diagnostics);
    }
    
    private checkSyntaxErrors(line: string, lineIndex: number): vscode.Diagnostic[] {
        const diagnostics: vscode.Diagnostic[] = [];
        
        // 检查未闭合的括号
        const openParens = (line.match(/\(/g) || []).length;
        const closeParens = (line.match(/\)/g) || []).length;
        
        if (openParens > closeParens) {
            const lastOpenParen = line.lastIndexOf('(');
            if (lastOpenParen !== -1) {
                const diagnostic = new vscode.Diagnostic(
                    new vscode.Range(lineIndex, lastOpenParen, lineIndex, lastOpenParen + 1),
                    '缺少闭合括号',
                    vscode.DiagnosticSeverity.Error
                );
                diagnostic.code = 'missing-close-paren';
                diagnostic.source = 'mylang';
                diagnostics.push(diagnostic);
            }
        }
        
        // 检查未闭合的大括号
        const openBraces = (line.match(/\{/g) || []).length;
        const closeBraces = (line.match(/\}/g) || []).length;
        
        if (openBraces > closeBraces && !line.trim().endsWith('{')) {
            const lastOpenBrace = line.lastIndexOf('{');
            if (lastOpenBrace !== -1) {
                const diagnostic = new vscode.Diagnostic(
                    new vscode.Range(lineIndex, lastOpenBrace, lineIndex, lastOpenBrace + 1),
                    '缺少闭合大括号',
                    vscode.DiagnosticSeverity.Error
                );
                diagnostic.code = 'missing-close-brace';
                diagnostic.source = 'mylang';
                diagnostics.push(diagnostic);
            }
        }
        
        // 检查未终止的字符串
        const quotes = (line.match(/"/g) || []).length;
        if (quotes % 2 === 1 && !line.trim().endsWith('\\')) {
            const lastQuote = line.lastIndexOf('"');
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, lastQuote, lineIndex, line.length),
                '未终止的字符串',
                vscode.DiagnosticSeverity.Error
            );
            diagnostic.code = 'unterminated-string';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        // 检查无效的关键字使用
        const invalidKeywordUsage = /\b(function|class|interface)\s*\(/g;
        let match;
        while ((match = invalidKeywordUsage.exec(line)) !== null) {
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, match.index, lineIndex, match.index + match[0].length),
                `关键字 ${match[1]} 使用错误`,
                vscode.DiagnosticSeverity.Error
            );
            diagnostic.code = 'invalid-keyword-usage';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        return diagnostics;
    }
    
    private checkUnusedVariables(document: vscode.TextDocument, lineIndex: number): vscode.Diagnostic[] {
        const diagnostics: vscode.Diagnostic[] = [];
        const line = document.lineAt(lineIndex).text;
        const text = document.getText();
        
        // 查找变量声明
        const variableDeclaration = /(var|let|const)\s+(\w+)/g;
        let match;
        
        while ((match = variableDeclaration.exec(line)) !== null) {
            const [, , variableName] = match;
            
            // 检查变量是否在其他地方被使用
            const usagePattern = new RegExp(`\\b${variableName}\\b`, 'g');
            const allMatches = Array.from(text.matchAll(usagePattern));
            
            // 如果只有一个匹配（就是声明本身），则认为未使用
            if (allMatches.length === 1) {
                const startPos = match.index + match[0].indexOf(variableName);
                const diagnostic = new vscode.Diagnostic(
                    new vscode.Range(lineIndex, startPos, lineIndex, startPos + variableName.length),
                    `变量 '${variableName}' 已声明但未使用`,
                    vscode.DiagnosticSeverity.Warning
                );
                diagnostic.code = 'unused-variable';
                diagnostic.source = 'mylang';
                diagnostic.tags = [vscode.DiagnosticTag.Unnecessary];
                diagnostics.push(diagnostic);
            }
        }
        
        return diagnostics;
    }
    
    private checkTypeErrors(line: string, lineIndex: number): vscode.Diagnostic[] {
        const diagnostics: vscode.Diagnostic[] = [];
        
        // 检查类型不匹配（简化版）
        const numberAssignment = /(\w+)\s*=\s*"[^"]*"/g;
        let match;
        
        while ((match = numberAssignment.exec(line)) !== null) {
            // 假设变量名包含 'num' 或 'count' 意味着应该是数字
            const variableName = match[1];
            if (variableName.includes('num') || variableName.includes('count') || variableName.includes('index')) {
                const diagnostic = new vscode.Diagnostic(
                    new vscode.Range(lineIndex, match.index, lineIndex, match.index + match[0].length),
                    `可能的类型错误：将字符串赋值给数字变量 '${variableName}'`,
                    vscode.DiagnosticSeverity.Warning
                );
                diagnostic.code = 'type-mismatch';
                diagnostic.source = 'mylang';
                diagnostics.push(diagnostic);
            }
        }
        
        return diagnostics;
    }
    
    private checkStyleIssues(line: string, lineIndex: number): vscode.Diagnostic[] {
        const diagnostics: vscode.Diagnostic[] = [];
        
        // 检查缩进问题
        if (line.match(/^\s*\t/)) {
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, 0, lineIndex, line.search(/[^\s]/)),
                '建议使用空格而不是制表符进行缩进',
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'tab-indentation';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        // 检查行尾空格
        if (line.match(/\s+$/)) {
            const trimmedLength = line.trimEnd().length;
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, trimmedLength, lineIndex, line.length),
                '行尾有多余的空格',
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'trailing-whitespace';
            diagnostic.source = 'mylang';
            diagnostic.tags = [vscode.DiagnosticTag.Unnecessary];
            diagnostics.push(diagnostic);
        }
        
        // 检查过长的行
        if (line.length > 100) {
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, 100, lineIndex, line.length),
                '行过长，建议不超过100个字符',
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'line-too-long';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        // 检查命名约定
        const variableDeclaration = /(var|let|const)\s+([A-Z]\w*)/g;
        let match;
        
        while ((match = variableDeclaration.exec(line)) !== null) {
            const variableName = match[2];
            const startPos = match.index + match[0].indexOf(variableName);
            
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, startPos, lineIndex, startPos + variableName.length),
                `变量名 '${variableName}' 应该使用驼峰命名法`,
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'naming-convention';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        return diagnostics;
    }
    
    private checkBestPractices(line: string, lineIndex: number): vscode.Diagnostic[] {
        const diagnostics: vscode.Diagnostic[] = [];
        
        // 检查console.log的使用
        if (line.includes('console.log')) {
            const index = line.indexOf('console.log');
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, index, lineIndex, index + 'console.log'.length),
                '生产代码中应避免使用console.log',
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'console-log-usage';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        // 检查var的使用
        if (line.includes('var ')) {
            const index = line.indexOf('var ');
            const diagnostic = new vscode.Diagnostic(
                new vscode.Range(lineIndex, index, lineIndex, index + 3),
                '建议使用let或const替代var',
                vscode.DiagnosticSeverity.Information
            );
            diagnostic.code = 'var-usage';
            diagnostic.source = 'mylang';
            diagnostics.push(diagnostic);
        }
        
        // 检查魔法数字
        const magicNumbers = /\b\d{2,}\b/g;
        let match;
        
        while ((match = magicNumbers.exec(line)) !== null) {
            const number = match[0];
            // 排除常见的非魔法数字
            if (!['100', '200', '404', '500'].includes(number)) {
                const diagnostic = new vscode.Diagnostic(
                    new vscode.Range(lineIndex, match.index, lineIndex, match.index + number.length),
                    `考虑将魔法数字 ${number} 定义为常量`,
                    vscode.DiagnosticSeverity.Information
                );
                diagnostic.code = 'magic-number';
                diagnostic.source = 'mylang';
                diagnostics.push(diagnostic);
            }
        }
        
        return diagnostics;
    }
    
    dispose(): void {
        this.diagnosticCollection.dispose();
    }
}