mimo-lang 1.1.1 → 2.0.6

package/parser/statements/variableParsers.js

@@ -0,0 +1,155 @@
+// In: parser/statements/variableParsers.js
+
+import { TokenType } from "../../lexer/TokenTypes.js";
+import { ASTNode } from "../ASTNodes.js";
+import { parseExpression } from "../parserExpressions.js";
+
+// Helper function that parses a "left-hand-side" expression,
+// which can be a simple identifier or a chain of property/bracket accesses.
+function parseAssignable(parser) {
+    let expr = parser.parseIdentifier('SYN097', "Expected an identifier for the variable name or assignment target.");
+
+    while (true) {
+        const token = parser.peek();
+        if (token?.type === TokenType.Operator && token.value === '.') {
+            parser.consume(); // consume '.'
+            const property = parser.expect(TokenType.Identifier, undefined, 'SYN098', 'Expected property name after dot.');
+            expr = ASTNode.PropertyAccess(expr, property.value, property);
+        } else if (token?.type === TokenType.LBracket) {
+            parser.consume(); // consume '['
+            const index = parseExpression(parser);
+            parser.expect(TokenType.RBracket, undefined, 'SYN100', "Expected a closing ']' after index.");
+            expr = ASTNode.ArrayAccess(expr, index, token);
+        } else {
+            break; // No more accessors
+        }
+    }
+    return expr;
+}
+
+
+export function parseVariableOrAssignment(parser, isExported = false, exportToken) {
+    const kindToken = parser.expectKeyword(['set', 'let', 'const', 'global'], 'SYN092');
+    const astNodeLocationToken = exportToken || kindToken;
+
+    const nextToken = parser.peek();
+    if (nextToken && (nextToken.type === TokenType.LBracket || nextToken.type === TokenType.LBrace)) {
+        const pattern = parseDestructuringPattern(parser);
+        const value = parseExpression(parser);
+        return ASTNode.VariableDeclaration(pattern, value, kindToken.value, isExported, astNodeLocationToken);
+    }
+
+    // We need the raw token for its position, not just the AST node.
+    const identifierToken = parser.expect(TokenType.Identifier, undefined, 'SYN097', "Expected an identifier for the variable name.");
+
+    // -- WHITESPACE-SENSITIVE AMBIGUITY RESOLUTION --
+    const followingToken = parser.peek();
+    let isMemberAssignment = false;
+
+    if (followingToken) {
+        if (followingToken.type === TokenType.Operator && followingToken.value === '.') {
+            // `obj.` is unambiguously a member assignment.
+            isMemberAssignment = true;
+        } else if (followingToken.type === TokenType.LBracket) {
+            // `arr[` vs `arr [`
+            // Your brilliant idea: check if there's a space.
+            const hasNoSpace = (followingToken.start === identifierToken.start + identifierToken.length);
+            if (hasNoSpace) {
+                isMemberAssignment = true;
+            }
+        }
+    }
+
+    // --- DISPATCH TO THE CORRECT PARSING PATH ---
+
+    if (isMemberAssignment) {
+        // --- PATH 1: MEMBER ASSIGNMENT (e.g., set arr[0] 99) ---
+        if (kindToken.value !== 'set') {
+            parser.error(`The '${kindToken.value}' keyword is for declarations. Use 'set' for direct member assignment.`, kindToken, 'SYN102');
+        }
+
+        let lhs = ASTNode.Identifier(identifierToken.value, identifierToken);
+
+        // Loop to consume the full accessor chain (e.g., obj.prop[0].name)
+        while (true) {
+            const currentToken = parser.peek();
+            const hasNoSpace = currentToken && (currentToken.start === parser.peek(-1).start + parser.peek(-1).length);
+
+            if (currentToken?.type === TokenType.Operator && currentToken.value === '.') {
+                parser.consume(); // consume '.'
+                const property = parser.expect(TokenType.Identifier, undefined, 'SYN098', 'Expected property name after dot.');
+                lhs = ASTNode.PropertyAccess(lhs, property.value, property);
+            } else if (currentToken?.type === TokenType.LBracket && hasNoSpace) {
+                parser.consume(); // consume '['
+                const index = parseExpression(parser);
+                parser.expect(TokenType.RBracket, undefined, 'SYN100', "Expected a closing ']' after index.");
+                lhs = ASTNode.ArrayAccess(lhs, index, currentToken);
+            } else {
+                break; // No more accessors
+            }
+        }
+
+        const value = parseExpression(parser);
+
+        if (lhs.type === 'PropertyAccess') {
+            return ASTNode.PropertyAssignment(lhs.object, lhs.property, value, astNodeLocationToken);
+        } else if (lhs.type === 'ArrayAccess') {
+            return ASTNode.BracketAssignment(lhs.object, lhs.index, value, astNodeLocationToken);
+        } else {
+            parser.error("Invalid member assignment target.", lhs, 'SYN103');
+        }
+
+    } else {
+        // --- PATH 2: VARIABLE DECLARATION (e.g., let x, set arr [1,2,3]) ---
+        const value = parseExpression(parser);
+        return ASTNode.VariableDeclaration(identifierToken.value, value, kindToken.value, isExported, astNodeLocationToken);
+    }
+}
+
+// NEW function to parse an object pattern like {a, b}
+function parseObjectPattern(parser) {
+    const startBrace = parser.expect(TokenType.LBrace, undefined, 'SYN115', 'Expected "{" to start object destructuring pattern.');
+    const properties = [];
+
+    if (parser.peek()?.type !== TokenType.RBrace) {
+        do {
+            // Each property in the pattern must be an identifier.
+            properties.push(parser.parseIdentifier('SYN116', 'Expected an identifier for property in object destructuring.'));
+        } while (parser.match(TokenType.Comma));
+    }
+
+    parser.expect(TokenType.RBrace, undefined, 'SYN117', 'Expected "}" to close object destructuring pattern.');
+    return ASTNode.ObjectPattern(properties, startBrace);
+}
+
+// (The destructuring parsers below remain unchanged and correct)
+function parseDestructuringPattern(parser) {
+    const token = parser.peek();
+
+    // Dispatch based on the opening token.
+    if (token.type === TokenType.LBracket) {
+        // Array Pattern: [a, b]
+        const startBracket = parser.consume();
+        const variables = [];
+        if (parser.peek()?.type !== TokenType.RBracket) {
+            do {
+                variables.push(parser.parseIdentifier("SYN110", "Expected an identifier in destructuring pattern."));
+            } while (parser.match(TokenType.Comma));
+        }
+        parser.expect(TokenType.RBracket, undefined, "SYN111", 'Expected a closing "]" for array destructuring pattern.');
+        return ASTNode.ArrayPattern(variables, startBracket);
+    } else if (token.type === TokenType.LBrace) {
+        // Object Pattern: {name, age}
+        return parseObjectPattern(parser); // Call our new helper
+    }
+
+    parser.error('Expected an array or object pattern (e.g., [a, b] or {a, b}) for destructuring.', token, 'SYN112');
+}
+
+export function parseDestructuringStatement(parser) {
+    const destructureToken = parser.expectKeyword("destructure", "SYN113");
+    const pattern = parseDestructuringPattern(parser);
+    parser.expectKeyword("from", "SYN114", 'Expected "from" keyword after destructuring pattern.');
+    const expression = parseExpression(parser);
+    return ASTNode.DestructuringAssignment(pattern, expression, destructureToken);
+}

package/repl.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env bun
+import readline from "node:readline";
+import { fileURLToPath } from 'url';
+import { nodeAdapter as adapter } from "./adapters/nodeAdapter.js";
+import { Interpreter } from "./interpreter/index.js";
+import { Lexer } from "./lexer/Lexer.js";
+import { Parser } from "./parser/Parser.js";
+import { stringify, highlightMimoCode } from "./interpreter/Utils.js";
+import { formatValue } from "./tools/replFormatter.js";
+import fs from "node:fs";
+import path from "node:path";
+import { getMimoType } from "./interpreter/suggestions.js";
+
+const HISTORY_FILE = path.join(process.cwd(), ".mimo_history");
+
+/**
+ * Tracking nesting levels for dynamic multiline input.
+ */
+class NestingTracker {
+    constructor() {
+        this.reset();
+    }
+
+    reset() {
+        this.nestedBlocks = 0; // for if, while, for, function, fn, try, match
+        this.openParens = 0;
+        this.openBrackets = 0;
+        this.openBraces = 0;
+    }
+
+    track(input) {
+        // Simple scanning for nesting indicators
+        // We use words for blocks, but avoid them in strings/comments
+        const tokens = input.split(/\s+/);
+
+        // Count keywords that increase depth
+        const blockStart = ["if", "while", "for", "function", "fn", "try", "match"];
+        const blockEnd = ["end"];
+
+        for (const token of tokens) {
+            if (blockStart.includes(token)) this.nestedBlocks++;
+            if (blockEnd.includes(token)) this.nestedBlocks--;
+        }
+
+        // Count individual chars for delimiters
+        for (const char of input) {
+            if (char === '(') this.openParens++;
+            if (char === ')') this.openParens--;
+            if (char === '[') this.openBrackets++;
+            if (char === ']') this.openBrackets--;
+            if (char === '{') this.openBraces++;
+            if (char === '}') this.openBraces--;
+        }
+    }
+
+    isBalanced() {
+        return this.nestedBlocks <= 0 &&
+            this.openParens <= 0 &&
+            this.openBrackets <= 0 &&
+            this.openBraces <= 0;
+    }
+}
+
+export function runRepl() {
+    const isInteractive = process.stdin.isTTY;
+
+    if (isInteractive) {
+        console.log("\x1b[1;35mWelcome to Mimo REPL!\x1b[0m");
+        console.log("Type \x1b[36m:help\x1b[0m for commands or \x1b[36mexit\x1b[0m to leave.");
+    }
+
+    const promptString = isInteractive ? "\x1b[36m(mimo)\x1b[0m " : "";
+    const multilinePrompt = isInteractive ? "\x1b[90m  ... \x1b[0m " : "";
+    const replFilePath = "/repl";
+
+    // Load history if exists and interactive
+    let history = [];
+    if (isInteractive && fs.existsSync(HISTORY_FILE)) {
+        history = fs.readFileSync(HISTORY_FILE, "utf-8").split("\n").filter(Boolean);
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: promptString,
+        historySize: 1000,
+        history: isInteractive ? history.reverse() : [],
+    });
+
+    let interpreter = new Interpreter(adapter);
+    const nesting = new NestingTracker();
+    const sessionHistory = [];
+
+    function processInput(input) {
+        // Save to history file if interactive
+        if (isInteractive) {
+            fs.appendFileSync(HISTORY_FILE, input.trim() + "\n");
+        }
+        sessionHistory.push(input);
+
+        interpreter.currentFile = replFilePath;
+        interpreter.errorHandler.addSourceFile(replFilePath, input);
+
+        try {
+            const lexer = new Lexer(input, replFilePath);
+            const tokens = [];
+            let token;
+            while ((token = lexer.nextToken()) !== null) {
+                tokens.push(token);
+            }
+
+            if (tokens.length === 0) return;
+
+            const parser = new Parser(tokens, replFilePath);
+            parser.setErrorHandler(interpreter.errorHandler);
+            const ast = parser.parse();
+
+            const result = interpreter.interpret(ast, replFilePath);
+            setLastResult(result);
+
+            const lastStatement = ast.body[ast.body.length - 1];
+            if (lastStatement && lastStatement.type !== "ShowStatement" && lastStatement.type !== "FunctionDeclaration") {
+                if (result !== undefined && result !== null) {
+                    const prefix = isInteractive ? "\x1b[90m=>\x1b[0m " : "=> ";
+                    console.log(`${prefix}${formatValue(result, isInteractive)}`);
+                }
+            }
+        } catch (err) {
+            interpreter.errorHandler.printError(err);
+        }
+    }
+
+    function parseToAst(source, filePath = replFilePath) {
+        const lexer = new Lexer(source, filePath);
+        const tokens = [];
+        let token;
+        while ((token = lexer.nextToken()) !== null) {
+            tokens.push(token);
+        }
+
+        const parser = new Parser(tokens, filePath);
+        parser.setErrorHandler(interpreter.errorHandler);
+        return parser.parse();
+    }
+
+    function setLastResult(value) {
+        if (value === undefined) return;
+        const existing = interpreter.globalEnv.getVariableInfo("_");
+        if (existing) {
+            existing.env.assign("_", value);
+        } else {
+            interpreter.globalEnv.define("_", value, "set");
+        }
+    }
+
+    function resetEnvironment() {
+        interpreter = new Interpreter(adapter);
+    }
+
+    function handleCommand(cmd) {
+        if (!isInteractive) return;
+        const trimmed = cmd.trim();
+        const parts = trimmed.split(/\s+/);
+        const action = parts[0].toLowerCase();
+        const payload = trimmed.slice(action.length).trim();
+
+        switch (action) {
+            case ".help":
+            case ":help":
+                console.log("\x1b[1mREPL Commands:\x1b[0m");
+                console.log("  \x1b[36m:help\x1b[0m     Show this help");
+                console.log("  \x1b[36m:clear\x1b[0m    Reset REPL environment");
+                console.log("  \x1b[36m:history\x1b[0m  Show recently used commands");
+                console.log("  \x1b[36m:type x\x1b[0m   Show Mimo type of variable x");
+                console.log("  \x1b[36m:load f\x1b[0m   Execute a .mimo file into current REPL env");
+                console.log("  \x1b[36m:save f\x1b[0m   Save REPL history to file");
+                console.log("  \x1b[36m:time expr\x1b[0m Measure expression/program execution time");
+                console.log("  \x1b[36m:ast expr\x1b[0m  Parse input and print AST JSON");
+                console.log("  \x1b[36m:exit\x1b[0m     Exit the REPL");
+                break;
+            case ".clear":
+            case ":clear":
+                resetEnvironment();
+                process.stdout.write("\u001b[2J\u001b[0;0H");
+                break;
+            case ".history":
+            case ":history":
+                rl.history
+                    .slice(0, 20)
+                    .reverse()
+                    .forEach((entry, idx) => console.log(`${idx + 1}. ${entry}`));
+                break;
+            case ":type": {
+                const targetName = parts[1];
+                if (!targetName) {
+                    console.log("Usage: :type <variable>");
+                    break;
+                }
+                try {
+                    const value = interpreter.currentEnv.lookup(targetName);
+                    console.log(getMimoType(value));
+                } catch {
+                    console.log(`Undefined variable: ${targetName}`);
+                }
+                break;
+            }
+            case ":load": {
+                if (!payload) {
+                    console.log("Usage: :load <file>");
+                    break;
+                }
+                const target = path.resolve(process.cwd(), payload);
+                if (!fs.existsSync(target)) {
+                    console.log(`File not found: ${target}`);
+                    break;
+                }
+                try {
+                    const source = fs.readFileSync(target, "utf-8");
+                    processInput(source);
+                } catch (err) {
+                    console.log(`Failed to load '${target}': ${err.message}`);
+                }
+                break;
+            }
+            case ":save": {
+                if (!payload) {
+                    console.log("Usage: :save <file>");
+                    break;
+                }
+                const target = path.resolve(process.cwd(), payload);
+                try {
+                    const sessionLines = sessionHistory
+                        .slice()
+                        .filter((entry) => entry && !entry.trim().startsWith(":") && !entry.trim().startsWith("."));
+                    fs.writeFileSync(target, `${sessionLines.join("\n")}\n`, "utf-8");
+                    console.log(`Saved ${sessionLines.length} entries to ${target}`);
+                } catch (err) {
+                    console.log(`Failed to save '${target}': ${err.message}`);
+                }
+                break;
+            }
+            case ":time": {
+                if (!payload) {
+                    console.log("Usage: :time <expr|statement>");
+                    break;
+                }
+                const start = process.hrtime.bigint();
+                processInput(payload);
+                const end = process.hrtime.bigint();
+                const elapsedMs = Number(end - start) / 1_000_000;
+                console.log(`\x1b[90mExecuted in ${elapsedMs.toFixed(3)} ms\x1b[0m`);
+                break;
+            }
+            case ":ast": {
+                if (!payload) {
+                    console.log("Usage: :ast <expr|statement>");
+                    break;
+                }
+                try {
+                    const ast = parseToAst(payload, "/repl_ast");
+                    console.log(JSON.stringify(ast, null, 2));
+                } catch (err) {
+                    interpreter.errorHandler.printError(err);
+                }
+                break;
+            }
+            case ".exit":
+            case ":exit":
+                rl.close();
+                break;
+            default:
+                console.log(`Unknown command: ${action}`);
+        }
+    }
+
+    let buffer = "";
+
+    rl.on("line", (line) => {
+        const trimmed = line.trim();
+
+        if (trimmed === "exit") {
+            rl.close();
+            return;
+        }
+
+        if ((trimmed.startsWith(".") || trimmed.startsWith(":")) && isInteractive) {
+            handleCommand(trimmed);
+            rl.prompt();
+            return;
+        }
+
+        buffer += (buffer ? "\n" : "") + line;
+        nesting.track(line);
+
+        if (nesting.isBalanced()) {
+            if (buffer.trim()) {
+                processInput(buffer);
+            }
+            buffer = "";
+            nesting.reset();
+            rl.setPrompt(promptString);
+        } else {
+            rl.setPrompt(multilinePrompt);
+        }
+
+        rl.prompt();
+    });
+
+    rl.on('close', () => {
+        if (isInteractive) {
+            console.log("\nBye!");
+        }
+        process.exit(0);
+    });
+
+    rl.prompt();
+}
+
+
+
+
+// This check ensures the REPL starts automatically only when `node repl.js` is run
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    runRepl();
+}

package/test.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { nodeAdapter as adapter } from './adapters/nodeAdapter.js';
+import { Mimo } from './index.js';
+
+
+async function runTest() {
+    const testName = process.argv[2] || 'all';
+    const filePath = findTestFile(testName);
+
+    if (!filePath) {
+        console.error(`Error: Test file "${testName}" not found.`);
+        return;
+    }
+
+    console.log(`\n=== Running Test: ${path.basename(filePath)} ===\n`);
+
+    const source = fs.readFileSync(filePath, 'utf-8');
+    const mimo = new Mimo(adapter);
+
+    try {
+        mimo.run(source, filePath);
+        console.log(`\n=== Test Passed: ${path.basename(filePath)} ===\n`);
+    } catch (err) {
+        console.error(err.message || err); // Show error even if it's a string
+        console.error(`\n=== Test FAILED: ${path.basename(filePath)} ===\n`);
+        process.exit(1);
+    }
+}
+
+
+function findTestFile(fileName) {
+    const directPath = path.resolve(process.cwd(), fileName);
+    if (fs.existsSync(directPath)) return directPath;
+
+    const withExt = directPath.endsWith('.mimo') ? '' : '.mimo';
+    if (fs.existsSync(`${directPath}${withExt}`)) return `${directPath}${withExt}`;
+
+    const testSourcePath = path.resolve(process.cwd(), 'test/source', fileName);
+    if (fs.existsSync(testSourcePath)) return testSourcePath;
+    if (fs.existsSync(`${testSourcePath}.mimo`)) return `${testSourcePath}.mimo`;
+
+    return null;
+}
+
+runTest();

package/tools/PrettyPrinter.js

@@ -0,0 +1,3 @@
+// tools/PrettyPrinter.js
+// Backwards-compatibility shim. The implementation now lives in tools/format/Printer.js.
+export { PrettyPrinter } from './format/Printer.js';

package/tools/convert/Args.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+
+export function parseArgs(args) {
+    const options = {};
+    if (args.length === 2 && !args[0].startsWith('--')) {
+        options.in = args[0];
+        options.out = args[1];
+        options.to = 'js';
+        return options;
+    }
+    for (let i = 0; i < args.length; i += 2) {
+        const flag = args[i];
+        const value = args[i + 1];
+        if (flag && flag.startsWith('--')) {
+            options[flag.substring(2)] = value;
+        }
+    }
+    return options;
+}
+
+/**
+ * Determine the target language and converter to use
+ */
+export function determineTarget(options, registry) {
+    let targetLanguage = options.to;
+
+    if (!targetLanguage && options.out) {
+        targetLanguage = registry.detectLanguageFromExtension(options.out);
+    }
+
+    if (!targetLanguage) {
+        targetLanguage = 'js';
+    }
+
+    const converterInfo = registry.get(targetLanguage);
+    if (!converterInfo) {
+        const availableLanguages = registry.getLanguages().join(', ');
+        throw new Error(`Unsupported target language: ${targetLanguage}. Available: ${availableLanguages}`);
+    }
+
+    return {
+        language: targetLanguage,
+        converterInfo,
+        targetExtension: converterInfo.extension
+    };
+}

package/tools/convert/Registry.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class ConverterRegistry {
+    constructor() {
+        this.converters = new Map();
+    }
+
+    /**
+     * Register a converter for a target language
+     */
+    register(language, extension, ConverterClass, runtimeFile = null) {
+        this.converters.set(language, {
+            extension,
+            ConverterClass,
+            runtimeFile
+        });
+    }
+
+    /**
+     * Get converter info for a language
+     */
+    get(language) {
+        return this.converters.get(language) || null;
+    }
+
+    /**
+     * Get all registered languages
+     */
+    getLanguages() {
+        return Array.from(this.converters.keys());
+    }
+
+    /**
+     * Detect target language from file extension
+     */
+    detectLanguageFromExtension(filePath) {
+        const ext = path.extname(filePath);
+        for (const [lang, info] of this.converters) {
+            if (info.extension === ext) {
+                return lang;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Dynamically scan the plugins directory and load all plugins
+     */
+    async discoverConverters() {
+        const pluginsDir = path.join(__dirname, 'plugins');
+        if (!fs.existsSync(pluginsDir)) return;
+
+        const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const langDir = path.join(pluginsDir, entry.name);
+                const indexPath = path.join(langDir, 'index.js');
+
+                if (fs.existsSync(indexPath)) {
+                    try {
+                        const modulePath = `file://${indexPath}`;
+                        const { config, Converter } = await import(modulePath);
+
+                        if (config && Converter) {
+                            const { name, aliases, extension, runtimeFile } = config;
+                            const regName = name || entry.name;
+                            const runtimePath = runtimeFile ? path.join(entry.name, runtimeFile) : null;
+
+                            this.register(regName, extension, Converter, runtimePath);
+
+                            if (aliases && Array.isArray(aliases)) {
+                                for (const alias of aliases) {
+                                    if (alias !== regName) {
+                                        this.register(alias, extension, Converter, runtimePath);
+                                    }
+                                }
+                            }
+                        }
+                    } catch (error) {
+                        console.warn(`Warning: Failed to load converter in ${entry.name}: ${error.message}`);
+                    }
+                }
+            }
+        }
+    }
+}