diff options
Diffstat (limited to 'js/baba-yaga/dev/vscode/out/extension.js')
| -rw-r--r-- | js/baba-yaga/dev/vscode/out/extension.js | 333 |
1 files changed, 333 insertions, 0 deletions
diff --git a/js/baba-yaga/dev/vscode/out/extension.js b/js/baba-yaga/dev/vscode/out/extension.js new file mode 100644 index 0000000..6e19efb --- /dev/null +++ b/js/baba-yaga/dev/vscode/out/extension.js @@ -0,0 +1,333 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.deactivate = exports.activate = void 0; +const vscode = __importStar(require("vscode")); +// Tree-sitter parser for Baba Yaga (optional) +let parser; +let BabaYagaLanguage; +async function activate(context) { + console.log('Baba Yaga extension is now active!'); + // Initialize Tree-sitter parser (optional) + const enableTreeSitter = vscode.workspace.getConfiguration('baba-yaga').get('enableTreeSitter'); + if (enableTreeSitter) { + try { + const Parser = require('tree-sitter'); + Parser.init(); + // Note: tree-sitter-baba-yaga grammar would need to be built separately + // For now, we'll use basic features without Tree-sitter + console.log('Tree-sitter enabled but grammar not available'); + } + catch (error) { + console.warn('Tree-sitter not available, using basic features:', error); + } + } + // Register commands + context.subscriptions.push(vscode.commands.registerCommand('baba-yaga.showTypeInfo', showTypeInfo), vscode.commands.registerCommand('baba-yaga.goToDefinition', goToDefinition), vscode.commands.registerCommand('baba-yaga.findReferences', findReferences), vscode.commands.registerCommand('baba-yaga.showFunctionSignature', showFunctionSignature)); + // Register language features + if (vscode.workspace.getConfiguration('baba-yaga').get('enableTypeHints')) { + context.subscriptions.push(vscode.languages.registerHoverProvider('baba-yaga', new BabaYagaHoverProvider()), vscode.languages.registerCompletionItemProvider('baba-yaga', new BabaYagaCompletionProvider(), '.', ':', '>')); + } + if (vscode.workspace.getConfiguration('baba-yaga').get('enableFunctionReferences')) { + context.subscriptions.push(vscode.languages.registerDefinitionProvider('baba-yaga', new BabaYagaDefinitionProvider()), vscode.languages.registerReferenceProvider('baba-yaga', new BabaYagaReferenceProvider())); + } + if (vscode.workspace.getConfiguration('baba-yaga').get('enableErrorChecking')) { + context.subscriptions.push(vscode.languages.registerDiagnosticCollection('baba-yaga', new BabaYagaDiagnosticProvider())); + } +} +exports.activate = activate; +function deactivate() { } +exports.deactivate = deactivate; +// Built-in functions and their signatures +const builtinFunctions = new Map([ + ['io.out', { name: 'io.out', kind: 'function', signature: 'io.out(value: any) -> void', description: 'Print value to console' }], + ['io.in', { name: 'io.in', kind: 'function', signature: 'io.in() -> String', description: 'Read input from console' }], + ['map', { name: 'map', kind: 'function', signature: 'map(func: (T) -> U, list: [T]) -> [U]', description: 'Apply function to each element' }], + ['filter', { name: 'filter', kind: 'function', signature: 'filter(pred: (T) -> Bool, list: [T]) -> [T]', description: 'Filter list by predicate' }], + ['reduce', { name: 'reduce', kind: 'function', signature: 'reduce(func: (acc: T, item: T) -> T, init: T, list: [T]) -> T', description: 'Fold list to single value' }], + ['append', { name: 'append', kind: 'function', signature: 'append(list: [T], item: T) -> [T]', description: 'Add item to end of list' }], + ['set', { name: 'set', kind: 'function', signature: 'set(table: Table, key: String, value: any) -> Table', description: 'Set table property' }], + ['merge', { name: 'merge', kind: 'function', signature: 'merge(table1: Table, table2: Table) -> Table', description: 'Merge two tables' }], + ['shape', { name: 'shape', kind: 'function', signature: 'shape(value: any) -> Table', description: 'Get value metadata' }] +]); +// String functions +const stringFunctions = ['concat', 'split', 'join', 'length', 'substring', 'replace', 'trim', 'upper', 'lower']; +stringFunctions.forEach(func => { + builtinFunctions.set(`str.${func}`, { + name: `str.${func}`, + kind: 'function', + signature: `str.${func}(...args) -> String`, + description: `String ${func} operation` + }); +}); +// Math functions +const mathFunctions = ['abs', 'sign', 'floor', 'ceil', 'round', 'trunc', 'min', 'max', 'clamp', 'pow', 'sqrt', 'exp', 'log', 'sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'deg', 'rad', 'random', 'randomInt']; +mathFunctions.forEach(func => { + builtinFunctions.set(`math.${func}`, { + name: `math.${func}`, + kind: 'function', + signature: `math.${func}(...args) -> Number`, + description: `Math ${func} operation` + }); +}); +// Keywords +const keywords = new Map([ + ['when', { name: 'when', kind: 'keyword', description: 'Pattern matching expression' }], + ['then', { name: 'then', kind: 'keyword', description: 'Pattern match result' }], + ['is', { name: 'is', kind: 'keyword', description: 'Pattern match operator' }], + ['Ok', { name: 'Ok', kind: 'keyword', description: 'Success result constructor' }], + ['Err', { name: 'Err', kind: 'keyword', description: 'Error result constructor' }], + ['true', { name: 'true', kind: 'keyword', description: 'Boolean true value' }], + ['false', { name: 'false', kind: 'keyword', description: 'Boolean false value' }], + ['PI', { name: 'PI', kind: 'keyword', description: 'Mathematical constant π' }], + ['INFINITY', { name: 'INFINITY', kind: 'keyword', description: 'Positive infinity' }], + ['and', { name: 'and', kind: 'keyword', description: 'Logical AND operator' }], + ['or', { name: 'or', kind: 'keyword', description: 'Logical OR operator' }], + ['xor', { name: 'xor', kind: 'keyword', description: 'Logical XOR operator' }] +]); +// Types +const types = new Map([ + ['Bool', { name: 'Bool', kind: 'type', description: 'Boolean type (true/false)' }], + ['Int', { name: 'Int', kind: 'type', description: 'Integer type' }], + ['Float', { name: 'Float', kind: 'type', description: 'Floating-point type' }], + ['String', { name: 'String', kind: 'type', description: 'String type' }], + ['List', { name: 'List', kind: 'type', description: 'List type [T]' }], + ['Table', { name: 'Table', kind: 'type', description: 'Table type {key: value}' }], + ['Result', { name: 'Result', kind: 'type', description: 'Result type (Ok T | Err String)' }], + ['Number', { name: 'Number', kind: 'type', description: 'Numeric supertype (Int | Float)' }] +]); +// Hover Provider +class BabaYagaHoverProvider { + provideHover(document, position, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + // Check built-in functions + const builtin = builtinFunctions.get(word); + if (builtin) { + return new vscode.Hover([ + `**${builtin.name}**`, + `\`${builtin.signature}\``, + builtin.description || '' + ]); + } + // Check keywords + const keyword = keywords.get(word); + if (keyword) { + return new vscode.Hover([ + `**${keyword.name}** (keyword)`, + keyword.description || '' + ]); + } + // Check types + const type = types.get(word); + if (type) { + return new vscode.Hover([ + `**${type.name}** (type)`, + type.description || '' + ]); + } + // Check for function definitions in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Hover([ + `**${word}** (function)`, + `\`${functionDef.signature}\``, + functionDef.description || '' + ]); + } + return null; + } +} +// Completion Provider +class BabaYagaCompletionProvider { + provideCompletionItems(document, position, token, context) { + const items = []; + // Add built-in functions + builtinFunctions.forEach((func, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Function); + item.detail = func.signature; + item.documentation = func.description; + items.push(item); + }); + // Add keywords + keywords.forEach((keyword, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.Keyword); + item.documentation = keyword.description; + items.push(item); + }); + // Add types + types.forEach((type, name) => { + const item = new vscode.CompletionItem(name, vscode.CompletionItemKind.TypeParameter); + item.documentation = type.description; + items.push(item); + }); + // Add operators + const operators = ['+', '-', '*', '/', '%', '=', '!=', '>', '<', '>=', '<=', '->', '..', ':', 'and', 'or', 'xor']; + operators.forEach(op => { + const item = new vscode.CompletionItem(op, vscode.CompletionItemKind.Operator); + items.push(item); + }); + return items; + } +} +// Definition Provider +class BabaYagaDefinitionProvider { + provideDefinition(document, position, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + // Find function definition in the document + const functionDef = findFunctionDefinition(document, word); + if (functionDef) { + return new vscode.Location(document.uri, functionDef.range); + } + return null; + } +} +// Reference Provider +class BabaYagaReferenceProvider { + provideReferences(document, position, context, token) { + const wordRange = document.getWordRangeAtPosition(position); + if (!wordRange) + return null; + const word = document.getText(wordRange); + const references = []; + // Find all references in the document + const text = document.getText(); + const regex = new RegExp(`\\b${word}\\b`, 'g'); + let match; + while ((match = regex.exec(text)) !== null) { + const startPos = document.positionAt(match.index); + const endPos = document.positionAt(match.index + match[0].length); + references.push(new vscode.Location(document.uri, new vscode.Range(startPos, endPos))); + } + return references; + } +} +// Diagnostic Provider +class BabaYagaDiagnosticProvider { + constructor() { + this.diagnosticCollection = vscode.languages.createDiagnosticCollection('baba-yaga'); + vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this); + } + onDidChangeTextDocument(event) { + if (event.document.languageId === 'baba-yaga') { + this.updateDiagnostics(event.document); + } + } + updateDiagnostics(document) { + const diagnostics = []; + const text = document.getText(); + // Basic syntax checking + const lines = text.split('\n'); + lines.forEach((line, index) => { + // Check for missing semicolons + if (line.trim() && !line.trim().startsWith('//') && !line.trim().endsWith(';') && !line.trim().endsWith('{') && !line.trim().endsWith('}')) { + const range = new vscode.Range(index, line.length, index, line.length); + diagnostics.push(new vscode.Diagnostic(range, 'Missing semicolon', vscode.DiagnosticSeverity.Warning)); + } + }); + this.diagnosticCollection.set(document.uri, diagnostics); + } +} +// Helper functions +function findFunctionDefinition(document, functionName) { + const text = document.getText(); + const lines = text.split('\n'); + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + const match = line.match(new RegExp(`\\b${functionName}\\s*:\\s*(.+?)\\s*->\\s*(.+?)\\s*;`)); + if (match) { + const signature = `${functionName} : ${match[1]} -> ${match[2]}`; + const startPos = document.positionAt(text.indexOf(line)); + const endPos = document.positionAt(text.indexOf(line) + line.length); + return { + signature, + range: new vscode.Range(startPos, endPos), + description: `Function defined at line ${i + 1}` + }; + } + } + return null; +} +// Command implementations +async function showTypeInfo() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const type = builtinFunctions.get(word) || keywords.get(word) || types.get(word); + if (type) { + vscode.window.showInformationMessage(`${word}: ${type.description || type.signature || type.name}`); + } +} +async function goToDefinition() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const functionDef = findFunctionDefinition(editor.document, word); + if (functionDef) { + editor.selection = new vscode.Selection(functionDef.range.start, functionDef.range.end); + editor.revealRange(functionDef.range); + } +} +async function findReferences() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + await vscode.commands.executeCommand('editor.action.referenceSearch.trigger'); +} +async function showFunctionSignature() { + const editor = vscode.window.activeTextEditor; + if (!editor || editor.document.languageId !== 'baba-yaga') + return; + const position = editor.selection.active; + const wordRange = editor.document.getWordRangeAtPosition(position); + if (!wordRange) + return; + const word = editor.document.getText(wordRange); + const builtin = builtinFunctions.get(word); + if (builtin) { + vscode.window.showInformationMessage(`${word}: ${builtin.signature}`); + } +} +//# sourceMappingURL=extension.js.map \ No newline at end of file |