mimo-lang 1.1.1 → 2.0.6

package/interpreter/ModuleLoader.js

@@ -0,0 +1,236 @@
+import { Lexer } from "../lexer/Lexer.js";
+import { ASTNode } from "../parser/ASTNodes.js";
+import { Parser } from "../parser/Parser.js";
+import { ErrorHandler } from "./ErrorHandler.js";
+import { Environment } from "./environment.js";
+import { MimoError } from "./MimoError.js";
+import { arrayModule } from "./stdlib/array.js";
+import { assertModule } from "./stdlib/assert.js";
+import { datetimeModule } from "./stdlib/datetime.js";
+import { envModule } from "./stdlib/env.js";
+import { fsModule } from "./stdlib/fs.js";
+import { httpModule } from "./stdlib/http.js";
+import { jsonModule } from "./stdlib/json.js";
+import { mathModuleExports } from "./stdlib/math.js";
+import { objectModule } from "./stdlib/object.js";
+import { pathModule } from "./stdlib/path.js";
+import { regexModule } from "./stdlib/regex.js";
+import { stringModuleExports } from "./stdlib/string.js";
+
+const internalStdLibModules = {
+  array: arrayModule,
+  datetime: datetimeModule,
+  env: envModule,
+  fs: fsModule,
+  http: httpModule,
+  json: jsonModule,
+  math: mathModuleExports,
+  object: objectModule,
+  path: pathModule,
+  regex: regexModule,
+  string: stringModuleExports,
+  assert: assertModule,
+};
+
+export class ModuleLoader {
+  constructor(interpreter) {
+    // console.log("ModuleLoader constructor: interpreter received:", interpreter); // Keep logs for now
+    this.interpreter = interpreter;
+    // console.log("ModuleLoader constructor: this.interpreter after assignment:", this.interpreter); // Keep logs for now
+
+    this.adapter = interpreter.adapter; // Adapter should be accessible
+    this.moduleCache = new Map();
+    this.loadingStack = new Set();
+
+    // Ensure executeModule is always bound to this instance
+    this.executeModule = this.executeModule.bind(this); // <--- Add this line
+  }
+  loadModule(importPath, fromFile) {
+    // Check if importPath is a known internal JS-backed stdlib module
+    if (Object.hasOwn(internalStdLibModules, importPath)) {
+      // If already "loaded" (cached) in moduleCache, return that
+      if (this.moduleCache.has(importPath)) {
+        return this.moduleCache.get(importPath);
+      }
+      const exports = internalStdLibModules[importPath];
+      this.moduleCache.set(importPath, exports); // Cache it by its name
+      return exports;
+    }
+
+    const resolvedPath = this.resolvePath(importPath, fromFile);
+
+    // Return cached module if already loaded
+    if (this.moduleCache.has(resolvedPath)) {
+      return this.moduleCache.get(resolvedPath);
+    }
+
+    // Check for circular dependency
+    if (this.loadingStack.has(resolvedPath)) {
+      const loadingChain = Array.from(this.loadingStack).join(" -> ");
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `Circular module dependency detected: ${loadingChain} -> ${resolvedPath}.`,
+        null, // No specific AST node for this type of error
+        "MOD003",
+        "Break the circular dependency by redesigning your module imports.",
+      );
+    }
+
+    // Load and execute module
+    this.loadingStack.add(resolvedPath);
+
+    try {
+      const exports = this.executeModule(resolvedPath);
+      this.moduleCache.set(resolvedPath, exports);
+      return exports;
+    } finally {
+      this.loadingStack.delete(resolvedPath);
+    }
+  }
+
+  resolvePath(importPath, fromFile) {
+    // Use adapter for path operations
+    const dir = this.adapter.dirname(fromFile);
+    const attemptedPaths = [];
+
+    let resolved = this.adapter.resolvePath(dir, importPath);
+    attemptedPaths.push(resolved);
+    if (this.adapter.existsSync(resolved)) {
+      return resolved;
+    }
+
+    resolved = this.adapter.resolvePath(dir, `${importPath}.mimo`);
+    attemptedPaths.push(resolved);
+    if (this.adapter.existsSync(resolved)) {
+      return resolved;
+    }
+    throw this.interpreter.errorHandler.createRuntimeError(
+      `Module '${importPath}' not found. Tried paths:\n${attemptedPaths
+        .map((p) => `  - ${p}`)
+        .join("\n")}`,
+      null, // No specific AST node for this path resolution error
+      "MOD001",
+      "Check the module path and ensure the file exists.",
+    );
+  }
+
+  executeModule(filePath) {
+    // console.log(
+    //   "\x1b[36m\n--- Inside ModuleLoader.executeModule for:",
+    //   filePath,
+    //   "---\x1b[0m"
+    // );
+    // console.log("  'this' in executeModule:", this);
+    // console.log("  'this.interpreter' in executeModule:", this.interpreter);
+    if (!this.interpreter) {
+      // console.error("CRITICAL: this.interpreter is undefined in executeModule!");
+      throw new Error(
+        "ModuleLoader critical error: interpreter instance is missing.",
+      );
+    }
+    // console.log("  'this.interpreter.currentEnv' in executeModule (before change):", this.interpreter.currentEnv);
+    // console.log("  'this.interpreter.globalEnv' in executeModule:", this.interpreter.globalEnv);
+
+    const originalInterpreterEnv = this.interpreter.currentEnv;
+    const originalInterpreterFile = this.interpreter.currentFile;
+
+    try {
+      const source = this.adapter.readFileSync(filePath, "utf8");
+      const lexer = new Lexer(source, filePath);
+      const tokens = [];
+      let token;
+      while ((token = lexer.nextToken()) !== null) {
+        tokens.push(token);
+      }
+      const parser = new Parser(tokens, filePath);
+      // Ensure parser also has access to the errorHandler for rich syntax errors
+      parser.setErrorHandler(this.interpreter.errorHandler); // <--- Crucial: Pass errorHandler to parser
+      const ast = parser.parse();
+
+      const moduleEnv = new Environment(this.interpreter.globalEnv);
+      moduleEnv.isModuleRoot = true;
+
+      // Set up module execution context on the interpreter instance
+      this.interpreter.currentEnv = moduleEnv; // <--- The problematic line
+      this.interpreter.currentFile = filePath;
+      this.interpreter.errorHandler.addSourceFile(filePath, source);
+
+      // console.log("  'this.interpreter.currentEnv' in executeModule (after change):", this.interpreter.currentEnv);
+
+      // Check if module has any explicit exports
+      let hasExplicitExports = false;
+      for (const statement of ast.body) {
+        if (statement.isExported === true) {
+          hasExplicitExports = true;
+          break;
+        }
+      }
+
+      // Execute module code
+      this.interpreter.visitNode(ast);
+
+      // Collect module exports
+      const exports = {};
+      if (hasExplicitExports) {
+        // Only export declarations with isExported = true
+        for (const statement of ast.body) {
+          if (statement.isExported === true) {
+            if (statement.type === "FunctionDeclaration") {
+              exports[statement.name] = moduleEnv.lookup(statement.name);
+            } else if (statement.type === "VariableDeclaration") {
+              exports[statement.identifier] = moduleEnv.lookup(
+                statement.identifier,
+              );
+            }
+            // Note: DestructuringAssignment, PropertyAssignment, and BracketAssignment
+            // don't currently support isExported flag, but could be added if needed
+          }
+        }
+      } else {
+        // Fallback: if no 'export' keywords were used, export everything (current behavior)
+        for (const [name, varInfo] of moduleEnv.vars.entries()) {
+          exports[name] = varInfo.value;
+        }
+      }
+
+      return exports;
+    } catch (error) {
+      // console.error("MODULE LOADER: Error during module execution for", filePath, ":", error);
+      if (error instanceof MimoError) {
+        throw error;
+      } // Re-throw MimoError as is
+      // Wrap any other JS errors. Need to pass an AST node if possible for location.
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `Error loading module '${filePath}': ${error.message}`,
+        null, // No specific AST node for the module file, pass null.
+        "MOD004",
+        "An unexpected error occurred while loading this module. Check its syntax or dependencies.",
+      );
+    } finally {
+      // Restore previous execution context
+      if (this.interpreter) {
+        // Check if interpreter exists before restoring (safety)
+        this.interpreter.currentEnv = originalInterpreterEnv;
+        this.interpreter.currentFile = originalInterpreterFile;
+        this.interpreter.errorHandler.clearSourceFile(filePath);
+      }
+      // console.log(
+      //   "\x1b[36m--- End ModuleLoader.executeModule for:",
+      //   filePath,
+      //   "---\x1b[0m"
+      // );
+    }
+  }
+
+  getModuleInfo(alias) {
+    // Helper method to get available properties for error messages
+    const moduleExports = this.interpreter.modules?.get(alias);
+    if (!moduleExports) {
+      return null;
+    }
+
+    return {
+      alias,
+      properties: Object.keys(moduleExports).sort(),
+    };
+  }
+}

package/interpreter/StatementExecutor.js

@@ -0,0 +1,107 @@
+import { ErrorHandler } from "./ErrorHandler.js";
+import { BaseExecutor } from "./executors/BaseExecutor.js";
+import { VariableExecutor } from "./executors/VariableExecutor.js";
+import { ControlFlowExecutor } from "./executors/ControlFlowExecutor.js";
+import { FunctionExecutor } from "./executors/FunctionExecutor.js";
+import { PatternMatchExecutor } from "./executors/PatternMatchExecutor.js";
+import { MimoError } from "./MimoError.js";
+
+
+export class StatementExecutor {
+  constructor(interpreter) {
+    this.interpreter = interpreter;
+
+    // Initialize specialized executors
+    this.baseExecutor = new BaseExecutor(interpreter);
+    this.variableExecutor = new VariableExecutor(interpreter);
+    this.controlFlowExecutor = new ControlFlowExecutor(interpreter);
+    this.functionExecutor = new FunctionExecutor(interpreter);
+    this.patternMatchExecutor = new PatternMatchExecutor(interpreter);
+  }
+
+  executeStatement(node) {
+    switch (node.type) {
+      case "Program":
+        return this.baseExecutor.executeProgram(node);
+
+      // Variable and assignment operations
+      case "VariableDeclaration":
+        return this.variableExecutor.executeVariableDeclaration(node);
+      case "DestructuringAssignment":
+        return this.variableExecutor.executeDestructuringAssignment(node);
+      case "PropertyAssignment":
+        return this.variableExecutor.executePropertyAssignment(node);
+      case "BracketAssignment":
+        return this.variableExecutor.executeBracketAssignment(node);
+
+      // Control flow operations
+      case "IfStatement":
+        return this.controlFlowExecutor.executeIfStatement(node);
+      case "GuardStatement":
+        return this.controlFlowExecutor.executeGuardStatement(node);
+      case "WhileStatement":
+        return this.controlFlowExecutor.executeWhileStatement(node);
+      case "ForStatement":
+        return this.controlFlowExecutor.executeForStatement(node);
+      case "LoopStatement":
+        return this.controlFlowExecutor.executeLoopStatement(node);
+      case "BreakStatement":
+        return this.controlFlowExecutor.executeBreakStatement(node);
+      case "ContinueStatement":
+        return this.controlFlowExecutor.executeContinueStatement(node);
+      case "TryStatement":
+        return this.controlFlowExecutor.executeTryStatement(node);
+      case "LabeledStatement":
+        return this.controlFlowExecutor.executeLabeledStatement(node);
+
+      // Function operations
+      case "FunctionDeclaration":
+        return this.functionExecutor.executeFunctionDeclaration(node);
+      case "CallStatement":
+        return this.functionExecutor.executeCallStatement(node);
+      case "ReturnStatement":
+        return this.functionExecutor.executeReturnStatement(node);
+      case "ShowStatement":
+        return this.functionExecutor.executeShowStatement(node);
+      case "ThrowStatement":
+        return this.functionExecutor.executeThrowStatement(node);
+
+      // Pattern matching operations
+      case "MatchStatement":
+        return this.patternMatchExecutor.executeMatchStatement(node);
+
+      // Module system operations
+      case "ImportStatement":
+        return this.executeImportStatement(node);
+
+      default:
+        throw this.interpreter.errorHandler.createRuntimeError(
+          `Unknown statement type: ${node.type}`,
+          node,
+          'RUN000',
+          'This indicates a bug in the interpreter. Please report this error.'
+        );
+    }
+  }
+
+
+  executeImportStatement(node) {
+    try {
+      const exports = this.interpreter.moduleLoader.loadModule(node.path, this.interpreter.currentFile);
+      this.interpreter.currentEnv.define(node.alias, exports, 'const');
+    } catch (error) {
+
+      if (error instanceof MimoError) {
+        throw error;
+      }
+
+      throw this.interpreter.errorHandler.createRuntimeError(
+        error.message,
+        node,
+        'MOD001',
+        'Check if the module path is correct and the module exists.'
+      );
+    }
+    return null;
+  }
+}

package/interpreter/Utils.js

@@ -0,0 +1,82 @@
+export function isTruthy(value) {
+  if (value === null || value === undefined) return false;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "string") return value.length > 0;
+  return true;
+}
+
+export function stringify(value, useColors = false) {
+  if (value === null || value === undefined) return useColors ? "\x1b[90mnull\x1b[0m" : "null";
+
+  if (value instanceof Date) {
+    const str = `datetime(${value.toISOString()})`;
+    return useColors ? `\x1b[32m${str}\x1b[0m` : str;
+  }
+
+  if (Array.isArray(value)) {
+    const items = value.map((v) => stringify(v, useColors)).join(useColors ? "\x1b[90m, \x1b[0m" : ", ");
+    return useColors ? `\x1b[90m[\x1b[0m${items}\x1b[90m]\x1b[0m` : `[${items}]`;
+  }
+
+  // Handle Function objects to avoid printing the AST in 'show'
+  if (value && typeof value === 'object' && (value.constructor.name === "FunctionValue" || value.constructor.name === "BuiltinFunction")) {
+    const label = value.name === '<anonymous>' ? 'anonymous function' : `function ${value.name}`;
+    return useColors ? `\x1b[36m[${label}]\x1b[0m` : `[${label}]`;
+  }
+
+  if (typeof value === "object" && value !== null) {
+    const pairs = Object.entries(value).map(([key, val]) => {
+      const k = useColors ? `\x1b[34m${key}\x1b[0m` : key;
+      return `${k}: ${stringify(val, useColors)}`;
+    });
+    return useColors ? `\x1b[90m{\x1b[0m${pairs.join(useColors ? "\x1b[90m, \x1b[0m" : ", ")}\x1b[90m}\x1b[0m` : `{${pairs.join(", ")}}`;
+  }
+
+  if (typeof value === "string") return useColors ? `\x1b[32m"${value}"\x1b[0m` : value;
+  if (typeof value === "number") return useColors ? `\x1b[33m${value}\x1b[0m` : String(value);
+  if (typeof value === "boolean") return useColors ? `\x1b[35m${value}\x1b[0m` : String(value);
+
+  return String(value);
+}
+
+/**
+ * Very basic syntax highlighting for Mimo code.
+ * @param {string} code 
+ * @returns {string} Colored ANSI string
+ */
+export function highlightMimoCode(code) {
+  // Keywords
+  const keywords = ["set", "let", "const", "global", "function", "fn", "return", "if", "else", "while", "for", "in", "try", "catch", "throw", "match", "case", "import", "from", "export", "as", "end", "call", "show"];
+  const operators = ["+", "-", "*", "/", "%", "=", "!=", "==", ">", "<", ">=", "<=", "and", "or", "not", "&&", "||", "!", "??", "?."];
+
+  let highlighted = code;
+
+  // Highlight strings - avoid highlighting inside highlighted parts
+  highlighted = highlighted.replace(/"[^"]*"/g, (match) => `\x1b[32m${match}\x1b[0m`);
+
+  // Highlight comments
+  highlighted = highlighted.replace(/#.*$/gm, (match) => `\x1b[90m${match}\x1b[0m`);
+
+  // Highlight numbers
+  highlighted = highlighted.replace(/\b\d+(\.\d+)?\b/g, (match) => `\x1b[33m${match}\x1b[0m`);
+
+  // Highlight boolean literals
+  highlighted = highlighted.replace(/\b(true|false|null)\b/g, (match) => `\x1b[35m${match}\x1b[0m`);
+
+  // Highlight keywords
+  for (const kw of keywords) {
+    const regex = new RegExp(`\\b${kw}\\b`, 'g');
+    highlighted = highlighted.replace(regex, (match) => `\x1b[1;36m${match}\x1b[0m`);
+  }
+
+  // Highlight operators
+  for (const op of operators) {
+    const escapedOp = op.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Avoid replacing inside ANSI escape codes
+    const regex = new RegExp(`(?<!\\x1b\\[[0-9;]*)(${escapedOp})(?![0-9;]*m)`, 'g');
+    highlighted = highlighted.replace(regex, (match) => `\x1b[31m${match}\x1b[0m`);
+  }
+
+  return highlighted;
+}

package/interpreter/Values.js

@@ -0,0 +1,87 @@
+import { Environment } from './environment.js';
+
+
+
+export class ReturnValue {
+    constructor(value) {
+        this.value = value;
+    }
+}
+
+export class BreakException {
+    constructor(label = null) {
+        this.label = label;
+    }
+}
+
+export class ContinueException {
+    constructor(label = null) {
+        this.label = label;
+    }
+}
+
+export class FunctionValue {
+    constructor(declaration, closure) {
+        this.declaration = declaration;
+        this.closure = closure;
+        // Add a name property, defaulting to '<anonymous>' if not declared.
+        this.name = declaration.name || '<anonymous>';
+    }
+
+    call(interpreter, args, callNode) {
+        const { params, defaults, restParam } = this.declaration;
+
+        // --- Arity Check ---
+        const requiredParamsCount = params.filter(pNode => !defaults[pNode.name]).length;
+        if (args.length < requiredParamsCount) {
+            throw interpreter.errorHandler.createRuntimeError(
+                `Function '${this.name}' expects at least ${requiredParamsCount} arguments but received ${args.length}.`,
+                callNode, 'FUNC001'
+            );
+        }
+        if (!restParam && args.length > params.length) {
+            throw interpreter.errorHandler.createRuntimeError(
+                `Function '${this.name}' expects at most ${params.length} arguments but received ${args.length}.`,
+                callNode, 'FUNC002'
+            );
+        }
+
+        // --- Environment Setup ---
+        const env = new Environment(this.closure, false, true);
+
+        // Bind regular parameters by iterating over the Identifier nodes
+        params.forEach((paramNode, i) => {
+            const paramName = paramNode.name;
+            let value = args[i]; // Get the passed argument
+
+            if (value === undefined) {
+                // If no argument was passed, check for a default value
+                if (defaults[paramName]) {
+                    value = interpreter.visitNode(defaults[paramName]);
+                } else {
+                    // This case should be caught by arity check, but is a safeguard
+                    throw new Error(`Interpreter Error: Missing value for required parameter ${paramName}`);
+                }
+            }
+            env.define(paramName, value);
+        });
+
+        // Handle rest parameter if it exists
+        if (restParam) {
+            const restArgs = args.slice(params.length);
+            env.define(restParam.name, restArgs);
+        }
+
+        // --- Execution ---
+        interpreter.pushCallStack(this.name, callNode);
+        try {
+            const result = interpreter.executeBlock(this.declaration.body, env);
+            if (result instanceof ReturnValue) {
+                return result.value;
+            }
+            return null; // Implicit return of null
+        } finally {
+            interpreter.popCallStack();
+        }
+    }
+}