mimo-lang 1.1.1 → 2.0.6

package/tools/convert/plugins/javascript/visitors/expressions.js

@@ -0,0 +1,197 @@
+/**
+ * Expression visitors for the Mimo → JavaScript converter.
+ * Mixed into MimoToJsConverter via Object.assign.
+ */
+export const expressionVisitors = {
+    visitBinaryExpression(node) {
+        const opMap = { '=': '===', '!=': '!==', '!': '!==', and: '&&', or: '||' };
+        const jsOp = opMap[node.operator] || node.operator;
+        this.write('(');
+        this.visitNode(node.left);
+        this.write(` ${jsOp} `);
+        this.visitNode(node.right);
+        this.write(')');
+    },
+
+    visitUnaryExpression(node) {
+        const opMap = { not: '!' };
+        const jsOp = opMap[node.operator] || node.operator;
+        this.write(`(${jsOp}`);
+        this.visitNode(node.argument);
+        this.write(')');
+    },
+
+    visitInlineIfExpression(node) {
+        // if cond then a else b  →  (cond ? a : b)
+        this.write('(');
+        this.visitNode(node.condition);
+        this.write(' ? ');
+        this.visitNode(node.consequent);
+        this.write(' : ');
+        this.visitNode(node.alternate);
+        this.write(')');
+    },
+
+    visitPipeExpression(node) {
+        // value |> callee(extraArgs)  →  callee(value, extraArgs)
+        // value |> if cond then f else g  →  (cond ? f : g)(value)
+        const callee = node.callee;
+        const extraArgs = node.args || [];
+
+        if (!callee) {
+            this.visitNode(node.left);
+            return;
+        }
+
+        if (callee.type === 'InlineIfExpression') {
+            this.write('(');
+            this.visitNode(callee.condition);
+            this.write(' ? ');
+            this.visitNode(callee.consequent);
+            this.write(' : ');
+            this.visitNode(callee.alternate);
+            this.write(')(');
+            this.visitNode(node.left);
+            this.write(')');
+        } else {
+            this.visitNode(callee);
+            this.write('(');
+            this.visitNode(node.left);
+            if (extraArgs.length > 0) {
+                this.write(', ');
+                this.emitArgs(extraArgs);
+            }
+            this.write(')');
+        }
+    },
+
+    visitIdentifier(node) {
+        this.write(node.name);
+    },
+
+    visitLiteral(node) {
+        this.write(JSON.stringify(node.value));
+    },
+
+    visitArrayLiteral(node) {
+        this.write('[');
+        node.elements.forEach((el, i) => {
+            if (el.type === 'SpreadElement') {
+                this.emitSpread(el);
+            } else {
+                this.visitNode(el);
+            }
+            if (i < node.elements.length - 1) this.write(', ');
+        });
+        this.write(']');
+    },
+
+    visitObjectLiteral(node) {
+        this.write('({');
+        node.properties.forEach((prop, i) => {
+            if (prop.type === 'SpreadElement') {
+                this.write('...');
+                this.visitNode(prop.argument);
+            } else {
+                this.write(`${JSON.stringify(prop.key)}: `);
+                this.visitNode(prop.value);
+            }
+            if (i < node.properties.length - 1) this.write(', ');
+        });
+        this.write('})');
+    },
+
+    visitTemplateLiteral(node) {
+        this.write('`');
+        node.parts.forEach((part) => {
+            if (part.type === 'Literal') {
+                this.write(this.escapeForTemplateLiteral(String(part.value)));
+            } else {
+                this.write('${');
+                this.visitNode(part);
+                this.write('}');
+            }
+        });
+        this.write('`');
+    },
+
+    visitRangeLiteral(node) {
+        this.write('mimo.range(');
+        this.visitNode(node.start);
+        this.write(', ');
+        this.visitNode(node.end);
+        this.write(')');
+    },
+
+    visitAnonymousFunction(node) {
+        this.enterScope();
+
+        const defaults = node.defaults || {};
+        const paramParts = (node.params || []).map((p) => {
+            this.declareVariable(p.name);
+            const defaultNode = defaults[p.name];
+            if (defaultNode !== undefined && defaultNode !== null) {
+                return `${p.name} = ${this._exprToString(defaultNode)}`;
+            }
+            return p.name;
+        });
+        if (node.restParam) {
+            this.declareVariable(node.restParam.name);
+            paramParts.push(`...${node.restParam.name}`);
+        }
+
+        this.write(`(${paramParts.join(', ')}) => {\n`);
+        this.visitBlock(node.body);
+        this.write(`${this.currentIndent}}`);
+
+        this.exitScope();
+    },
+
+    visitCallExpression(node) {
+        this.visitCallee(node.callee);
+        this.write('(');
+        this.emitArgs(node.arguments);
+        this.write(')');
+    },
+
+    visitSafeCallExpression(node) {
+        // func?.(...args) — wrap in ?? null to match Mimo semantics (undefined → null)
+        this.write('(');
+        this.visitNode(node.callee);
+        this.write('?.(');
+        this.emitArgs(node.arguments || []);
+        this.write(') ?? null)');
+    },
+
+    visitModuleAccess(node) {
+        this.write(`${node.module}.${node.property}`);
+    },
+
+    visitPropertyAccess(node) {
+        this.visitNode(node.object);
+        this.write(`.${node.property}`);
+    },
+
+    visitSafePropertyAccess(node) {
+        // Wrap in ?? null to match Mimo semantics (undefined → null)
+        this.write('(');
+        this.visitNode(node.object);
+        this.write(`?.${node.property} ?? null)`);
+    },
+
+    visitArrayAccess(node) {
+        this.visitNode(node.object);
+        this.write('[');
+        this.visitNode(node.index);
+        this.write(']');
+    },
+
+    visitSafeArrayAccess(node) {
+        // arr?.[index] — wrap in ?? null to match Mimo semantics (undefined → null)
+        this.write('(');
+        this.visitNode(node.object);
+        this.write('?.[');
+        this.visitNode(node.index);
+        this.write('] ?? null)');
+    },
+};

package/tools/convert/plugins/javascript/visitors/patterns.js

@@ -0,0 +1,102 @@
+/**
+ * Pattern matching visitors for the Mimo → JavaScript converter.
+ * Mixed into MimoToJsConverter via Object.assign.
+ */
+export const patternVisitors = {
+    visitArrayPattern(node) {
+        this.write(`[${node.elements.map((e) => e.name).join(', ')}]`);
+    },
+
+    visitObjectPattern(node) {
+        this.write(`{ ${node.properties.map((p) => p.name).join(', ')} }`);
+    },
+
+    visitDecorator(_node) {
+        // Decorators are handled inside visitFunctionDeclaration.
+    },
+
+    visitMatchStatement(node) {
+        const tempVar = `__match_${this._matchCounter++}`;
+        this.write(`${this.currentIndent}const ${tempVar} = `);
+        this.visitNode(node.discriminant);
+        this.write(';\n');
+        this.writeLine(`switch (true) {`);
+        this.indent();
+        node.cases.forEach((caseNode) => this._visitCaseClause(caseNode, tempVar));
+        this.dedent();
+        this.writeLine('}');
+    },
+
+    _visitCaseClause(node, matchVar) {
+        if (!node.pattern) {
+            // default case
+            this.writeLine('default: {');
+        } else {
+            this.write(`${this.currentIndent}case (`);
+            this._emitMatchCondition(node.pattern, matchVar);
+            // Handle `when` guard
+            if (node.guard) {
+                this.write(' && (');
+                this._emitMatchBindingsInline(node.pattern, matchVar);
+                this.visitNode(node.guard);
+                this.write(')');
+            }
+            this.write('): {\n');
+            this.indent();
+            this._emitMatchBindings(node.pattern, matchVar);
+            this.dedent();
+        }
+        this.visitBlock(node.consequent);
+        this.writeLine('break;');
+        this.writeLine('}');
+    },
+
+    _emitMatchCondition(pattern, matchVar) {
+        if (!pattern) { this.write('true'); return; }
+        switch (pattern.type) {
+            case 'Literal':
+                this.write(`mimo.eq(${matchVar}, `);
+                this.visitNode(pattern);
+                this.write(')');
+                break;
+            case 'Identifier':
+                this.write('true');
+                break;
+            case 'ArrayPattern':
+                this.write(`Array.isArray(${matchVar}) && ${matchVar}.length === ${pattern.elements.length}`);
+                pattern.elements.forEach((el, i) => {
+                    this.write(' && ');
+                    this._emitMatchCondition(el, `${matchVar}[${i}]`);
+                });
+                break;
+            case 'ObjectPattern':
+                this.write(`(${matchVar} !== null && typeof ${matchVar} === 'object')`);
+                break;
+            default:
+                this.write('true');
+        }
+    },
+
+    /** Emit bindings as part of a `when` guard expression (no-op; bindings run after the case label). */
+    _emitMatchBindingsInline(_pattern, _matchVar) {},
+
+    _emitMatchBindings(pattern, matchVar) {
+        if (!pattern) return;
+        switch (pattern.type) {
+            case 'Identifier':
+                this.writeLine(`const ${pattern.name} = ${matchVar};`);
+                break;
+            case 'ArrayPattern':
+                pattern.elements.forEach((el, i) =>
+                    this._emitMatchBindings(el, `${matchVar}[${i}]`)
+                );
+                break;
+            case 'ObjectPattern':
+                pattern.properties.forEach((prop) => {
+                    const key = prop.key || prop.name;
+                    this.writeLine(`const ${prop.name} = ${matchVar}["${key}"];`);
+                });
+                break;
+        }
+    },
+};

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

@@ -0,0 +1,236 @@
+/**
+ * Statement visitors for the Mimo → JavaScript converter.
+ * Mixed into MimoToJsConverter via Object.assign.
+ */
+export const statementVisitors = {
+    visitShowStatement(node) {
+        this.write(`${this.currentIndent}mimo.show(`);
+        this.visitNode(node.expression);
+        this.write(');\n');
+    },
+
+    visitVariableDeclaration(node) {
+        let keyword = 'let';
+        if (node.kind === 'const') keyword = 'const';
+        // Mimo's `set` is mutable and function-scoped (not block-scoped).
+        // Use `var` to match this: declared once with `var`, subsequent uses are bare assignments.
+        if (node.kind === 'set') keyword = 'var';
+
+        let prefix;
+        if (this.isVariableDeclared(node.identifier)) {
+            prefix = '';
+        } else {
+            prefix = node.isExported ? `export ${keyword} ` : `${keyword} `;
+            this.declareVariable(node.identifier);
+        }
+
+        this.write(`${this.currentIndent}${prefix}${node.identifier} = `);
+        this.visitNode(node.value);
+        this.write(';\n');
+    },
+
+    visitFunctionDeclaration(node) {
+        this.declareVariable(node.name);
+        const exportPrefix = node.isExported ? 'export ' : '';
+
+        // Handle decorators (bottom-up application order)
+        const decorators = node.decorators || [];
+
+        this.enterScope();
+
+        // Build parameter list with defaults and rest params
+        const defaults = node.defaults || {};
+        const paramParts = (node.params || []).map((p) => {
+            this.declareVariable(p.name);
+            const defaultNode = defaults[p.name];
+            if (defaultNode !== undefined && defaultNode !== null) {
+                return `${p.name} = ${this._exprToString(defaultNode)}`;
+            }
+            return p.name;
+        });
+        if (node.restParam) {
+            this.declareVariable(node.restParam.name);
+            paramParts.push(`...${node.restParam.name}`);
+        }
+
+        this.write(`${this.currentIndent}${exportPrefix}function ${node.name}(${paramParts.join(', ')}) {\n`);
+        this.visitBlock(node.body);
+        this.writeLine('}');
+
+        this.exitScope();
+
+        // Apply decorators: fn = decorator(fn)
+        // Mimo applies decorators in reverse order (innermost/last decorator first),
+        // matching Python's @decorator stacking semantics.
+        for (const dec of [...decorators].reverse()) {
+            const decName = typeof dec.name === 'string' ? dec.name : dec.name?.name;
+            const decArgs = dec.arguments || dec.args || [];
+            const decCall = decArgs.length > 0
+                ? `${decName}(${decArgs.map(a => this._exprToString(a)).join(', ')})(${node.name})`
+                : `${decName}(${node.name})`;
+            this.writeLine(`${node.name} = ${decCall};`);
+        }
+    },
+
+    visitCallStatement(node) {
+        if (node.destination) {
+            const destName = node.destination.name;
+            const keyword = this.isVariableDeclared(destName) ? '' : 'let ';
+            this.write(`${this.currentIndent}${keyword}${destName} = `);
+            this.declareVariable(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) {
+            this.write(`${this.currentIndent}} else `);
+            if (node.alternate.type === 'IfStatement') {
+                this.visitNode(node.alternate);
+            } else {
+                this.write('{\n');
+                this.visitBlock(node.alternate);
+                this.writeLine('}');
+            }
+        } else {
+            this.writeLine('}');
+        }
+    },
+
+    visitGuardStatement(node) {
+        // guard cond else ... end  →  if (!cond) { <alternate-block> }
+        this.write(`${this.currentIndent}if (!(`);
+        this.visitNode(node.condition);
+        this.write(')) {\n');
+        this.visitBlock(node.alternate || node.elseBlock || []);
+        this.writeLine('}');
+    },
+
+    visitWhileStatement(node) {
+        this.write(`${this.currentIndent}while (`);
+        this.visitNode(node.condition);
+        this.write(') {\n');
+        this.visitBlock(node.body);
+        this.writeLine('}');
+    },
+
+    visitForStatement(node) {
+        this.write(`${this.currentIndent}for (const ${node.variable.name} of `);
+        this.visitNode(node.iterable);
+        this.write(') {\n');
+        this.visitBlock(node.body);
+        this.writeLine('}');
+    },
+
+    visitLoopStatement(node) {
+        if (node.label) this.writeLine(`${node.label}:`);
+        this.writeLine('while (true) {');
+        this.visitBlock(node.body);
+        this.writeLine('}');
+    },
+
+    visitLabeledStatement(node) {
+        this.writeLine(`${node.label}:`);
+        this.visitNode(node.statement);
+    },
+
+    visitBreakStatement(node) {
+        this.write(`${this.currentIndent}break`);
+        if (node.label) this.write(` ${node.label}`);
+        this.write(';\n');
+    },
+
+    visitContinueStatement(node) {
+        this.write(`${this.currentIndent}continue`);
+        if (node.label) this.write(` ${node.label}`);
+        this.write(';\n');
+    },
+
+    visitTryStatement(node) {
+        this.writeLine('try {');
+        this.visitBlock(node.tryBlock);
+        if (node.catchBlock) {
+            const errName = node.catchVar?.name || '_err';
+            this.write(`${this.currentIndent}} catch (${errName}) {\n`);
+            this.visitBlock(node.catchBlock);
+        }
+        this.writeLine('}');
+    },
+
+    visitThrowStatement(node) {
+        this.write(`${this.currentIndent}throw `);
+        this.visitNode(node.argument);
+        this.write(';\n');
+    },
+
+    visitImportStatement(node) {
+        this.moduleAliases.set(node.alias, node.path);
+        if (this.isStdlibModule(node.path)) {
+            this.writeLine(`const ${node.alias} = mimo.${node.path};`);
+        } else {
+            const importPath = node.path.endsWith('.mimo')
+                ? node.path.replace('.mimo', '.js')
+                : `${node.path}.js`;
+            this.writeLine(`import * as ${node.alias} from './${importPath}';`);
+        }
+    },
+
+    visitDestructuringAssignment(node) {
+        const patternVars = this._collectPatternVars(node.pattern);
+        const isReassignment = patternVars.some((v) => this.isVariableDeclared(v));
+
+        this.write(this.currentIndent);
+
+        if (isReassignment) {
+            if (node.pattern.type === 'ObjectPattern') this.write('(');
+        } else {
+            this.write('let ');
+        }
+
+        this.visitNode(node.pattern);
+        this.write(' = ');
+        this.visitNode(node.expression);
+
+        if (isReassignment && node.pattern.type === 'ObjectPattern') this.write(')');
+        this.write(';\n');
+
+        patternVars.forEach((v) => this.declareVariable(v));
+    },
+
+    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');
+    },
+};

package/tools/convert/plugins/python/index.js

@@ -0,0 +1,10 @@
+import { MimoToPyConverter } from './to_py.js';
+
+export const config = {
+    name: 'python',
+    aliases: ['py', 'python'],
+    extension: '.py',
+    runtimeFile: 'mimo_runtime.py'
+};
+
+export { MimoToPyConverter as Converter };