mimo-lang 1.1.1 → 2.0.6

package/tools/convert/plugins/python/visitors/statements.js

@@ -0,0 +1,257 @@
+/**
+ * Statement visitors for the Mimo → Python converter.
+ * Mixed into MimoToPyConverter via Object.assign.
+ */
+export const statementVisitors = {
+    visitShowStatement(node) {
+        this.write(`${this.currentIndent}mimo.show(`);
+        this.visitNode(node.expression);
+        this.write(')\n');
+    },
+
+    visitVariableDeclaration(node) {
+        this.write(`${this.currentIndent}${node.identifier} = `);
+        this.visitNode(node.value);
+        this.write('\n');
+    },
+
+    visitFunctionDeclaration(node) {
+        const decorators = node.decorators || [];
+
+        // Build parameter list with defaults and rest params
+        const defaults = node.defaults || {};
+        const paramParts = (node.params || []).map((p) => {
+            const defaultNode = defaults[p.name];
+            if (defaultNode !== undefined && defaultNode !== null) {
+                return `${p.name}=${this._exprToString(defaultNode)}`;
+            }
+            return p.name;
+        });
+        if (node.restParam) {
+            paramParts.push(`*${node.restParam.name}`);
+        }
+
+        // Collect parameters and locals to exclude from global declarations
+        const paramNames = new Set((node.params || []).map(p => p.name));
+        if (node.restParam) paramNames.add(node.restParam.name);
+
+        // Find module-level vars that are assigned inside this function body
+        const assignedInBody = this._collectAssignedVars(node.body);
+        const globalsNeeded = [...assignedInBody].filter(
+            v => this._moduleVars.has(v) && !paramNames.has(v)
+        );
+
+        this.writeLine(`def ${node.name}(${paramParts.join(', ')}):`);
+        // Emit global declarations before the body
+        if (globalsNeeded.length > 0) {
+            this.indent();
+            this.writeLine(`global ${globalsNeeded.join(', ')}`);
+            this.dedent();
+        }
+
+        // Track variables declared in this function for nested closure detection
+        const funcVars = new Set([...paramNames, ...this._collectAssignedVars(node.body)]);
+        this._enclosingFunctionVars.push(funcVars);
+        this.visitBlock(node.body);
+        this._enclosingFunctionVars.pop();
+        this.writeLine();
+
+        // Apply decorators immediately after function definition.
+        // When emitting hoisted functions (visitProgram pass 1), defer all decorator
+        // applications so that all functions are defined before any decorator is applied.
+        for (const dec of [...decorators].reverse()) {
+            const decName = typeof dec.name === 'string' ? dec.name : dec.name?.name;
+            const decArgs = dec.arguments || dec.args || [];
+            let decLine;
+            if (decArgs.length > 0) {
+                const argStr = decArgs.map((a) => this._exprToString(a)).join(', ');
+                decLine = `${node.name} = ${decName}(${argStr})(${node.name})`;
+            } else {
+                decLine = `${node.name} = ${decName}(${node.name})`;
+            }
+            if (this._emittingHoistedFunctions) {
+                this._deferredDecorators.push(decLine);
+            } else {
+                this.writeLine(decLine);
+            }
+        }
+        if (decorators.length > 0 && !this._emittingHoistedFunctions) this.writeLine();
+    },
+
+    visitCallStatement(node) {
+        if (node.destination) {
+            const destName = node.destination.name;
+            this.write(`${this.currentIndent}${destName} = `);
+        } else {
+            this.write(this.currentIndent);
+        }
+
+        this.visitCallee(node.callee);
+        this.write('(');
+        this.emitArgs(node.arguments);
+        this.write(')\n');
+    },
+
+    visitReturnStatement(node) {
+        this.write(`${this.currentIndent}return`);
+        if (node.argument) {
+            this.write(' ');
+            this.visitNode(node.argument);
+        }
+        this.write('\n');
+    },
+
+    visitIfStatement(node) {
+        this.write(`${this.currentIndent}if `);
+        this.visitNode(node.condition);
+        this.write(':\n');
+        this.visitBlock(node.consequent);
+
+        if (node.alternate) {
+            if (node.alternate.type === 'IfStatement') {
+                // `elif` — prefix with `el` then let visitIfStatement emit `if`
+                this.write(`${this.currentIndent}el`);
+                this.visitNode(node.alternate);
+            } else {
+                this.writeLine('else:');
+                this.visitBlock(node.alternate);
+            }
+        }
+    },
+
+    visitGuardStatement(node) {
+        // guard cond else ... end  →  if not (cond): <alternate-block>
+        this.write(`${this.currentIndent}if not (`);
+        this.visitNode(node.condition);
+        this.write('):\n');
+        this.visitBlock(node.alternate || node.elseBlock || []);
+    },
+
+    visitWhileStatement(node) {
+        this.write(`${this.currentIndent}while `);
+        this.visitNode(node.condition);
+        this.write(':\n');
+        this.visitBlock(node.body);
+    },
+
+    visitForStatement(node) {
+        this.write(`${this.currentIndent}for ${node.variable.name} in `);
+        this.visitNode(node.iterable);
+        this.write(':\n');
+        this.visitBlock(node.body);
+    },
+
+    visitLoopStatement(node) {
+        if (node.label) this.writeLine(`# label: ${node.label}`);
+        this.writeLine('while True:');
+        this.visitBlock(node.body);
+    },
+
+    visitLabeledStatement(node) {
+        this.writeLine(`# label: ${node.label}`);
+        this.visitNode(node.statement);
+    },
+
+    visitBreakStatement(node) {
+        // Python doesn't support labeled break; emit a comment if label present
+        if (node.label) this.writeLine(`# break ${node.label} (labeled break not supported in Python)`);
+        this.writeLine('break');
+    },
+
+    visitContinueStatement(node) {
+        if (node.label) this.writeLine(`# continue ${node.label} (labeled continue not supported in Python)`);
+        this.writeLine('continue');
+    },
+
+    visitTryStatement(node) {
+        this.writeLine('try:');
+        this.visitBlock(node.tryBlock);
+        if (node.catchBlock) {
+            const errName = node.catchVar?.name || '_err';
+            const tmpName = `_exc_${errName}`;
+            this.writeLine(`except Exception as ${tmpName}:`);
+            this.indent();
+            // Coerce the exception to a string so it behaves like in Mimo/JS
+            this.writeLine(`${errName} = str(${tmpName})`);
+            (node.catchBlock || []).forEach((stmt) => this.visitNode(stmt));
+            this.dedent();
+        }
+    },
+
+    visitThrowStatement(node) {
+        this.write(`${this.currentIndent}raise Exception(`);
+        this.visitNode(node.argument);
+        this.write(')\n');
+    },
+
+    visitImportStatement(node) {
+        this.moduleAliases.set(node.alias, node.path);
+        if (this.isStdlibModule(node.path)) {
+            // Bind the stdlib sub-object from the mimo runtime
+            this.writeLine(`${node.alias} = mimo.${node.path}`);
+        } else {
+            // External import was already emitted as a top-level `import` statement.
+            // Just bind the alias name so the rest of the code works.
+            this.writeLine(`${node.alias} = ${node.alias}`);
+        }
+    },
+
+    visitDestructuringAssignment(node) {
+        if (node.pattern.type === 'ObjectPattern') {
+            // Python can't unpack dicts like JS, emit individual assignments
+            const exprStr = this._exprToString(node.expression);
+            this._emitObjectDestructuring(node.pattern, exprStr);
+        } else if (node.pattern.type === 'ArrayPattern') {
+            // Array pattern: emit individual index assignments to handle extra elements
+            // e.g. [x, y] = arr  →  __tmp = arr; x = mimo.get(__tmp, 0); y = mimo.get(__tmp, 1)
+            const elements = node.pattern.elements || [];
+            if (elements.length === 0) return;
+            const tmpVar = `__tmp_${this._matchCounter++}`;
+            this.write(`${this.currentIndent}${tmpVar} = `);
+            this.visitNode(node.expression);
+            this.write('\n');
+            elements.forEach((el, i) => {
+                if (el && el.name) {
+                    this.writeLine(`${el.name} = mimo.get(${tmpVar}, ${i})`);
+                }
+            });
+        } else {
+            this.write(this.currentIndent);
+            this.visitNode(node.pattern);
+            this.write(' = ');
+            this.visitNode(node.expression);
+            this.write('\n');
+        }
+    },
+
+    visitPropertyAssignment(node) {
+        this.write(this.currentIndent);
+        this.visitNode(node.object);
+        this.write(`["${node.property}"] = `);
+        this.visitNode(node.value);
+        this.write('\n');
+    },
+
+    visitBracketAssignment(node) {
+        this.write(this.currentIndent);
+        this.visitNode(node.object);
+        this.write('[');
+        this.visitNode(node.index);
+        this.write('] = ');
+        this.visitNode(node.value);
+        this.write('\n');
+    },
+
+    /**
+     * Emit a Python object destructuring assignment.
+     * Python can't do `a, b = obj` for dicts, so we expand it as:
+     *   a = obj.get("a")
+     *   b = obj.get("b")
+     */
+    _emitObjectDestructuring(pattern, exprStr) {
+        pattern.properties.forEach((prop) => {
+            const key = prop.key || prop.name;
+            this.writeLine(`${prop.name} = (${exprStr}).get("${key}")`);
+        });
+    },
+};

package/tools/convert.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Mimo Language Converter - Standardized Entry Point
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { ConverterRegistry } from './convert/Registry.js';
+import { parseArgs, determineTarget } from './convert/Args.js';
+import { Transpiler } from './convert/Transpiler.js';
+
+const converterRegistry = new ConverterRegistry();
+
+async function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => { resolve(data); });
+    });
+}
+
+async function main(providedArgs) {
+    const args = providedArgs || process.argv.slice(2);
+    const options = parseArgs(args);
+
+    // Initialize the registry by discovering plugins
+    await converterRegistry.discoverConverters();
+
+    if ((!options.in && process.stdin.isTTY) || !options.out) {
+        const availableLanguages = converterRegistry.getLanguages().join(', ');
+        console.error('Usage: mimo convert --in <infile> --out <outfile|outdir> [--to <language>]');
+        console.error('Or pipe to stdin: echo "..." | mimo convert --out <outfile> [--to <language>]');
+        console.error(`Available target languages: ${availableLanguages}`);
+        process.exit(1);
+    }
+
+    let targetConfig;
+    try {
+        targetConfig = determineTarget(options, converterRegistry);
+    } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+
+    const { language, converterInfo, targetExtension } = targetConfig;
+    const transpiler = new Transpiler();
+
+    let outDir;
+    let isFileOutput = false;
+
+    if (path.extname(options.out) === targetExtension) {
+        outDir = path.dirname(options.out);
+        isFileOutput = true;
+        console.log(`Converting ${options.in ? `'${options.in}'` : 'STDIN'} to ${language.toUpperCase()} file '${options.out}'...`);
+    } else {
+        outDir = options.out;
+        console.log(`Converting ${options.in ? `'${options.in}'` : 'STDIN'} to ${language.toUpperCase()} in directory '${options.out}'...`);
+    }
+
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+
+    if (isFileOutput) {
+        if (options.in) {
+            transpiler.transpileMainFile(options.in, options.out, converterInfo);
+        } else {
+            const source = await readStdin();
+            const output = transpiler.transpileSource(source, 'stdin', converterInfo);
+            fs.writeFileSync(options.out, output, 'utf-8');
+        }
+    } else {
+        if (options.in) {
+            transpiler.transpileFile(options.in, outDir, converterInfo, targetExtension);
+        } else {
+            console.error('Error: Directory output requires an input file to resolve dependencies.');
+            process.exit(1);
+        }
+
+        // Copy runtime if exists
+        if (converterInfo.runtimeFile) {
+            const __dirname = path.dirname(fileURLToPath(import.meta.url));
+            const runtimeSourcePath = path.join(__dirname, 'convert', 'plugins', converterInfo.runtimeFile);
+            const runtimeFileName = path.basename(converterInfo.runtimeFile);
+
+            if (fs.existsSync(runtimeSourcePath)) {
+                fs.copyFileSync(runtimeSourcePath, path.join(outDir, runtimeFileName));
+                console.log(` -> Copied runtime: ${runtimeFileName}`);
+            }
+        }
+    }
+
+    console.log(`✅ Conversion to ${language.toUpperCase()} successful!`);
+}
+
+export { main as runConverter };
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main();
+}

package/tools/format/CommentAttacher.js

@@ -0,0 +1,190 @@
+/**
+ * tools/format/CommentAttacher.js
+ *
+ * Attaches extracted comments to the nearest AST nodes so the Printer
+ * can re-emit them in the correct positions.
+ *
+ * Attachment rules (line-number based):
+ *
+ *  leadingComments — a comment is "leading" for node N if:
+ *    - The comment ends on the line immediately before N starts, OR
+ *    - The comment is a block of consecutive line-comments that sits above N
+ *      with no intervening blank lines between the block and N.
+ *
+ *  trailingComment — a comment is "trailing" for node N if:
+ *    - It starts on the same line that N ends on (inline comment).
+ *    - Only the first such comment is attached (one trailing comment per node).
+ *
+ * After attachment the comment is marked `attached = true` so it is not
+ * double-emitted. Any remaining unattached comments are prepended to the
+ * Program body as synthetic leading comments on a virtual sentinel node
+ * (the Program node itself gets them as `node.leadingComments`).
+ *
+ * Limitations (acceptable for v1):
+ *   - Comments inside expressions (e.g. inside array literals) are treated as
+ *     leading comments of the next sibling statement, not the sub-expression.
+ *   - Only top-level Program.body and inner block arrays are walked; deeply
+ *     nested expression trees are not traversed for attachment purposes.
+ */
+
+/**
+ * Mutates the AST in-place by setting `leadingComments` and `trailingComment`
+ * on statement nodes where comments can be meaningfully attached.
+ *
+ * @param {object}   ast       Parsed Program node
+ * @param {object[]} comments  Output of CommentLexer.extractComments()
+ */
+export function attachComments(ast, comments) {
+    if (!comments.length) return;
+
+    // Work on a copy we can mark as attached
+    const pool = comments.map(c => ({ ...c, attached: false }));
+
+    // Walk every list of statements in the tree
+    _attachToStatementList(ast.body, pool);
+
+    // Any leftover comments at the very top (before first statement) go on the Program
+    const unattached = pool.filter(c => !c.attached);
+    if (unattached.length) {
+        ast.leadingComments = (ast.leadingComments ?? []).concat(unattached);
+    }
+}
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+function _nodeEndLine(node) {
+    // Most nodes have `line` = their start line. We approximate end line by
+    // looking for the deepest child with a line property, or we just use
+    // start line (safe conservative estimate — trailing comments still work
+    // because they are same-line as the keyword that opens the node).
+    return node.line ?? 1;
+}
+
+function _nodeStartLine(node) {
+    return node.line ?? 1;
+}
+
+/**
+ * Attach comments to a flat list of statement nodes.
+ * Recurses into block-owning nodes.
+ */
+function _attachToStatementList(statements, pool) {
+    if (!statements?.length) return;
+
+    for (let i = 0; i < statements.length; i++) {
+        const node = statements[i];
+        const startLine = _nodeStartLine(node);
+
+        // ── Leading comments ─────────────────────────────────────────────────
+        // Collect unattached comments that appear immediately before this node.
+        // "immediately before" = comment line is < startLine, and there is no
+        // blank line between the last comment in the block and this node.
+        const leading = [];
+        // Walk pool in reverse to find the contiguous block just above this node
+        let expectedLine = startLine - 1;
+        for (let j = pool.length - 1; j >= 0; j--) {
+            const c = pool[j];
+            if (c.attached) continue;
+            if (c.line > startLine) continue; // comment is after this node — skip
+            if (c.line === expectedLine || c.line === expectedLine + 1 || c.line < startLine) {
+                // Check contiguity: only attach if no gap
+                if (c.line >= startLine - 20 && c.line < startLine) {
+                    // Check that no non-comment, non-blank source appears between c and node
+                    // (we use a simple line-distance heuristic)
+                    leading.unshift(c);
+                    c.attached = true;
+                    expectedLine = c.line - 1;
+                }
+            }
+        }
+
+        // Filter: only keep comments that form a contiguous block touching this node
+        const attached = _filterContiguousLeading(leading, startLine);
+        if (attached.length) {
+            node.leadingComments = attached;
+        }
+
+        // ── Trailing comment ─────────────────────────────────────────────────
+        // A comment on the same line as this node's start line (for single-line
+        // statements) or a comment on the line of the closing keyword.
+        for (const c of pool) {
+            if (c.attached) continue;
+            if (c.line === startLine && c.kind === 'line') {
+                node.trailingComment = c;
+                c.attached = true;
+                break;
+            }
+        }
+
+        // ── Recurse into child blocks ─────────────────────────────────────────
+        _recurseIntoNode(node, pool);
+    }
+}
+
+/**
+ * Filter the collected leading candidates to only the contiguous block that
+ * immediately precedes `startLine` (no blank-line gaps).
+ */
+function _filterContiguousLeading(candidates, startLine) {
+    if (!candidates.length) return [];
+    // candidates is already sorted ascending by line
+    // Work backwards from startLine to find the contiguous run
+    const result = [];
+    let expectedLine = startLine - 1;
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const c = candidates[i];
+        if (c.line === expectedLine || c.line === expectedLine - 0) {
+            result.unshift(c);
+            expectedLine = c.line - 1;
+        } else if (c.line < expectedLine - 1) {
+            // Gap found — stop
+            break;
+        } else {
+            result.unshift(c);
+            expectedLine = c.line - 1;
+        }
+    }
+    return result;
+}
+
+/**
+ * Recurse into the child statement lists of block-owning nodes.
+ */
+function _recurseIntoNode(node, pool) {
+    switch (node.type) {
+        case 'FunctionDeclaration':
+        case 'AnonymousFunction':
+            _attachToStatementList(node.body, pool);
+            break;
+        case 'IfStatement':
+            _attachToStatementList(node.consequent, pool);
+            if (Array.isArray(node.alternate)) {
+                _attachToStatementList(node.alternate, pool);
+            } else if (node.alternate) {
+                _recurseIntoNode(node.alternate, pool);
+            }
+            break;
+        case 'GuardStatement':
+            _attachToStatementList(node.alternate, pool);
+            break;
+        case 'WhileStatement':
+        case 'ForStatement':
+        case 'LoopStatement':
+            _attachToStatementList(node.body, pool);
+            break;
+        case 'TryStatement':
+            _attachToStatementList(node.tryBlock, pool);
+            _attachToStatementList(node.catchBlock, pool);
+            break;
+        case 'MatchStatement':
+            for (const c of (node.cases ?? [])) {
+                _attachToStatementList(c.consequent, pool);
+            }
+            break;
+        case 'LabeledStatement':
+            if (node.statement) _recurseIntoNode(node.statement, pool);
+            break;
+        default:
+            break;
+    }
+}

package/tools/format/CommentLexer.js

@@ -0,0 +1,152 @@
+/**
+ * tools/format/CommentLexer.js
+ *
+ * A lightweight, self-contained scanner that extracts all comments from raw
+ * Mimo source without going through the main Lexer/Parser pipeline.
+ *
+ * This is the formatter-only path for comment preservation (A1).
+ * It deliberately does NOT touch the main lexer or any interpreter code.
+ *
+ * Returns:
+ *   {
+ *     comments: Array<{ kind: 'line'|'block', value: string, line: number,
+ *                        column: number, startOffset: number, endOffset: number }>,
+ *     lineOffsets: number[]   // lineOffsets[n] = char offset where line n+1 starts
+ *   }
+ */
+
+export function extractComments(source) {
+    const comments = [];
+    // lineOffsets[i] = char index of the first character of line (i+1).
+    // lineOffsets[0] = 0 (line 1 starts at offset 0)
+    const lineOffsets = [0];
+
+    let i = 0;
+    let line = 1;
+    let column = 1;
+
+    // Track whether we are inside a string or template literal so we don't
+    // mistake comment-like sequences inside strings for actual comments.
+    let inString = false;
+    let inTemplate = 0; // nesting depth for backtick templates
+    let inInterpolation = 0; // depth of ${ } inside templates
+
+    function advance() {
+        const ch = source[i];
+        i++;
+        if (ch === '\n') {
+            lineOffsets.push(i);
+            line++;
+            column = 1;
+        } else {
+            column++;
+        }
+        return ch;
+    }
+
+    function peek(offset = 0) {
+        return source[i + offset] ?? null;
+    }
+
+    while (i < source.length) {
+        const ch = peek();
+
+        // ── Template literals ────────────────────────────────────────────────
+        if (!inString && ch === '`') {
+            advance();
+            inTemplate++;
+            continue;
+        }
+        if (inTemplate > 0 && !inString) {
+            if (ch === '`') {
+                advance();
+                inTemplate--;
+                continue;
+            }
+            if (ch === '$' && peek(1) === '{') {
+                advance(); advance();
+                inInterpolation++;
+                continue;
+            }
+            if (inInterpolation === 0) {
+                // inside template fragment — consume (handle escapes)
+                if (ch === '\\') { advance(); advance(); continue; }
+                advance();
+                continue;
+            }
+            // inside interpolation — fall through to normal processing
+            if (ch === '}') {
+                advance();
+                inInterpolation--;
+                continue;
+            }
+        }
+
+        // ── Regular strings ──────────────────────────────────────────────────
+        if (!inString && (ch === '"' || ch === "'")) {
+            const quote = ch;
+            advance();
+            inString = true;
+            while (i < source.length) {
+                const sc = peek();
+                if (sc === '\\') { advance(); advance(); continue; }
+                if (sc === quote) { advance(); inString = false; break; }
+                if (sc === '\n') { advance(); break; } // unterminated — let the real lexer handle it
+                advance();
+            }
+            continue;
+        }
+
+        // ── Line comment: // ─────────────────────────────────────────────────
+        if (ch === '/' && peek(1) === '/') {
+            const startOffset = i;
+            const startLine = line;
+            const startCol = column;
+            advance(); advance(); // consume '//'
+            let value = '';
+            while (i < source.length && peek() !== '\n') {
+                value += peek();
+                advance();
+            }
+            comments.push({
+                kind: 'line',
+                value: value.trim(),
+                line: startLine,
+                column: startCol,
+                startOffset,
+                endOffset: i,
+            });
+            continue;
+        }
+
+        // ── Block comment: /* … */ ───────────────────────────────────────────
+        if (ch === '/' && peek(1) === '*') {
+            const startOffset = i;
+            const startLine = line;
+            const startCol = column;
+            advance(); advance(); // consume '/*'
+            let value = '';
+            while (i < source.length) {
+                if (peek() === '*' && peek(1) === '/') {
+                    advance(); advance();
+                    break;
+                }
+                value += peek();
+                advance();
+            }
+            comments.push({
+                kind: 'block',
+                value: value.trim(),
+                line: startLine,
+                column: startCol,
+                startOffset,
+                endOffset: i,
+            });
+            continue;
+        }
+
+        advance();
+    }
+
+    return { comments, lineOffsets };
+}