mimo-lang 1.1.1 → 2.0.6

package/interpreter/evaluators/collectionEvaluator.js

@@ -0,0 +1,151 @@
+// In interpreter/evaluators/collectionEvaluator.js
+import { suggestNearestName } from "../suggestions.js";
+
+export function evaluateArrayLiteral(interpreter, node) {
+  const result = [];
+  for (const element of node.elements) {
+    if (element.type === "SpreadElement") {
+      const spreadValue = interpreter.visitNode(element.argument);
+      if (!Array.isArray(spreadValue)) {
+        throw interpreter.errorHandler.createRuntimeError(
+          `Cannot spread non-array value of type '${typeof spreadValue}'.`,
+          element,
+          "TYPE001",
+          'Spread operator "..." can only be used with arrays.'
+        );
+      }
+      result.push(...spreadValue);
+    } else {
+      result.push(interpreter.visitNode(element));
+    }
+  }
+  return result;
+}
+
+export function evaluateArrayAccess(interpreter, node) {
+  const object = interpreter.visitNode(node.object);
+  const index = interpreter.visitNode(node.index); // This is the key or the index
+
+  // Case 1: The target is an Array
+  if (Array.isArray(object)) {
+    if (typeof index !== 'number' || !Number.isInteger(index)) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `Array index must be an integer. Got type '${typeof index}'.`,
+        node.index, 'TYPE001', "Provide an integer for array indexing."
+      );
+    }
+    return (index < 0 || index >= object.length) ? null : object[index];
+  }
+
+  // Case 2: The target is an Object
+  if (typeof object === 'object' && object !== null) {
+    const key = String(index);
+    return Object.prototype.hasOwnProperty.call(object, key) ? object[key] : null;
+  }
+
+  // Case 3: The target is a String
+  if (typeof object === 'string') {
+    if (typeof index !== 'number' || !Number.isInteger(index)) {
+      throw interpreter.errorHandler.createRuntimeError(
+        `String index must be an integer. Got type '${typeof index}'.`,
+        node.index, 'TYPE001', "Provide an integer for string character access."
+      );
+    }
+    return (index < 0 || index >= object.length) ? null : object.charAt(index);
+  }
+
+  // If none of the above, it's an error
+  throw interpreter.errorHandler.createRuntimeError(
+    `Cannot access property on value of type '${typeof object}'. Only arrays, objects, and strings can be indexed.`,
+    node.object, 'TYPE002', "Ensure you are using bracket notation on a valid collection type."
+  );
+}
+
+export function evaluateObjectLiteral(interpreter, node) {
+  const obj = {};
+  for (const prop of node.properties) {
+    if (prop && prop.type === "SpreadElement") {
+      const spreadValue = interpreter.visitNode(prop.argument);
+      if (typeof spreadValue !== 'object' || spreadValue === null || Array.isArray(spreadValue)) {
+        throw interpreter.errorHandler.createRuntimeError(
+          `Cannot spread non-object value of type '${typeof spreadValue}'.`,
+          prop.argument,
+          "TYPE001",
+          'Object spread operator "..." can only be used with objects.'
+        );
+      }
+      Object.assign(obj, spreadValue);
+    } else {
+      const value = interpreter.visitNode(prop.value);
+      obj[prop.key] = value;
+    }
+  }
+  return obj;
+}
+
+export function evaluatePropertyAccess(interpreter, node) {
+  const object = interpreter.visitNode(node.object);
+
+  if (object === null || object === undefined) {
+    throw interpreter.errorHandler.createRuntimeError(
+      `Cannot access property '${node.property}' of 'null'.`,
+      node.object, // AST node for the object being accessed
+      "REF001",
+      "Ensure the object is not null or undefined before accessing its properties. Consider using safe navigation (?. )."
+    );
+  }
+
+  // Allow property access on strings (e.g., `my_string.length`)
+  if (typeof object !== "object" && typeof object !== "string") {
+    throw interpreter.errorHandler.createRuntimeError(
+      `Cannot access property '${node.property
+      }' of non-object value of type '${typeof object}'.`,
+      node.object,
+      "TYPE002",
+      "Properties can only be accessed on objects or strings."
+    );
+  }
+
+  if (!(node.property in object)) {
+    const candidates = typeof object === "object" && object !== null
+      ? Object.keys(object)
+      : Object.getOwnPropertyNames(object);
+    const nearest = suggestNearestName(node.property, candidates);
+    const suggestion = nearest
+      ? `Did you mean '${nearest}'?`
+      : "Check for typos or ensure the property exists.";
+    throw interpreter.errorHandler.createRuntimeError(
+      `Property '${node.property}' does not exist on ${Array.isArray(object) ? "array" : typeof object}.`,
+      node,
+      "PROP001",
+      suggestion
+    );
+  }
+
+  return object[node.property];
+}
+
+export function evaluateSafePropertyAccess(interpreter, node) {
+  const object = interpreter.visitNode(node.object);
+
+  if (object === null || object === undefined) {
+    return null;
+  }
+
+  // If property doesn't exist, return null instead of letting evaluatePropertyAccess throw
+  if (!(node.property in object)) {
+    return null;
+  }
+
+  return evaluatePropertyAccess(interpreter, { ...node, type: 'PropertyAccess' });
+}
+
+export function evaluateSafeArrayAccess(interpreter, node) {
+  const object = interpreter.visitNode(node.object);
+
+  if (object === null || object === undefined) {
+    return null;
+  }
+
+  return evaluateArrayAccess(interpreter, { ...node, type: 'ArrayAccess' });
+}

package/interpreter/evaluators/functionCallEvaluator.js

@@ -0,0 +1,76 @@
+// interpreter/evaluators/functionCallEvaluator.js
+
+import { FunctionValue } from '../Values.js';
+import { BuiltinFunction } from '../BuiltinFunction.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+
+export function evaluateAnonymousFunction(interpreter, node) {
+    // Create a function value with the current environment as closure
+    return new FunctionValue(node, interpreter.currentEnv);
+}
+
+export function evaluateCallExpression(interpreter, node) {
+    // Evaluate the callee (could be identifier or module access)
+    let func;
+    let functionName;
+
+    if (typeof node.callee === 'string') {
+        // Legacy support for string callee
+        func = interpreter.currentEnv.lookup(node.callee);
+        functionName = node.callee;
+    } else {
+        // New AST node callee (Identifier, ModuleAccess, or expression)
+        func = interpreter.visitNode(node.callee);
+        if (node.callee.type === 'ModuleAccess') {
+            functionName = `${node.callee.module}.${node.callee.property}`;
+        } else if (node.callee.type === 'Identifier') {
+            functionName = node.callee.name;
+        } else {
+            functionName = '<anonymous function>';
+        }
+    }
+
+    if (
+        !(func instanceof FunctionValue) &&
+        !(func instanceof BuiltinFunction)
+    ) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `'${functionName}' is not a callable function.`,
+            node,
+            'TYPE002',
+            'Ensure you are calling a function or method.'
+        );
+    }
+
+    const args = [];
+    for (const arg of node.arguments) {
+        if (arg.type === 'SpreadElement') {
+            const spreadValue = interpreter.visitNode(arg.argument);
+            if (!Array.isArray(spreadValue)) {
+                throw interpreter.errorHandler.createRuntimeError(
+                    `Cannot spread non-array value in function call.`,
+                    arg.argument,
+                    'TYPE001'
+                );
+            }
+            args.push(...spreadValue);
+        } else {
+            args.push(interpreter.visitNode(arg));
+        }
+    }
+    const result = func.call(interpreter, args, node); // Pass the CallExpression node
+
+    return result;
+}
+
+export function evaluateSafeCallExpression(interpreter, node) {
+    const calleeValue = interpreter.visitNode(node.callee);
+
+    if (calleeValue === null || calleeValue === undefined) {
+        return null;
+    }
+
+    // Since we already evaluated the callee, we could refine this to avoid double evaluation.
+    // However, to keep it simple and consistent with other safe navigation implementations:
+    return evaluateCallExpression(interpreter, { ...node, type: 'CallExpression' });
+}

package/interpreter/evaluators/literalEvaluator.js

@@ -0,0 +1,27 @@
+// interpreter/evaluators/literalEvaluator.js
+import { suggestNearestName } from "../suggestions.js";
+
+export function evaluateIdentifier(interpreter, node) {
+    try {
+        return interpreter.currentEnv.lookup(node.name);
+    } catch (error) {
+        if (error?.message?.startsWith("Undefined variable:")) {
+            const candidates = interpreter.currentEnv.getVisibleNames();
+            const nearest = suggestNearestName(node.name, candidates);
+            const suggestion = nearest
+                ? `Did you mean '${nearest}'?`
+                : "Declare the variable before using it.";
+            throw interpreter.errorHandler.createRuntimeError(
+                `Undefined variable '${node.name}'.`,
+                node,
+                "REF001",
+                suggestion
+            );
+        }
+        throw error;
+    }
+}
+
+export function evaluateLiteral(interpreter, node) {
+    return node.value;
+}

package/interpreter/evaluators/moduleAccessEvaluator.js

@@ -0,0 +1,25 @@
+
+export function evaluateModuleAccess(interpreter, node) {
+    // A module alias is now just a regular variable in the environment.
+    // The `import` statement defines it as a constant object.
+    const moduleObject = interpreter.currentEnv.lookup(node.module);
+
+    if (typeof moduleObject !== 'object' || moduleObject === null) {
+        throw interpreter.errorHandler.createRuntimeError(
+            `Cannot access property on non-module/non-object '${node.module}'.`,
+            node.module, 'TYPE002'
+        );
+    }
+
+    // Check if property exists in the module's exports object.
+    if (!Object.prototype.hasOwnProperty.call(moduleObject, node.property)) {
+        const availableProps = Object.keys(moduleObject).sort();
+        throw interpreter.errorHandler.createRuntimeError(
+            `Property '${node.property}' not found in module '${node.module}'.`,
+            node, 'MOD002',
+            `Available properties in '${node.module}': ${availableProps.join(', ')}`
+        );
+    }
+
+    return moduleObject[node.property];
+}

package/interpreter/evaluators/templateLiteralEvaluator.js

@@ -0,0 +1,20 @@
+// interpreter/evaluators/templateLiteralEvaluator.js
+
+import { stringify } from '../Utils.js';
+
+export function evaluateTemplateLiteral(interpreter, node) {
+    let resultString = "";
+    
+    for (const part of node.parts) {
+        if (part.type === 'Literal') {
+            // This is a string fragment from the template
+            resultString += part.value;
+        } else {
+            // This is an interpolated expression - evaluate it and stringify
+            const value = interpreter.visitNode(part);
+            resultString += stringify(value);
+        }
+    }
+    
+    return resultString;
+}

package/interpreter/executors/BaseExecutor.js

@@ -0,0 +1,37 @@
+import { ErrorHandler } from "../ErrorHandler.js";
+import { ReturnValue } from "../Values.js";
+
+export class BaseExecutor {
+  constructor(interpreter) {
+    this.interpreter = interpreter;
+  }
+
+  // Helper function to find the nearest function scope or global scope
+  findFunctionScope(env) {
+    let currentEnv = env;
+    while (currentEnv && !currentEnv.isGlobalScope) {
+      if (currentEnv.vars.size > 0) {
+        return currentEnv;
+      }
+      currentEnv = currentEnv.parent;
+    }
+    return currentEnv || this.interpreter.globalEnv;
+  }
+
+  // Helper: treat any environment that is the closure for a function as a function scope
+  isFunctionScope(env) {
+    return env.isFunctionContext; // Now correctly identifies function scopes
+  }
+
+  executeProgram(node) {
+    this.interpreter.hoistFunctionDeclarations(node.body);
+    let result = null;
+    for (const statement of node.body) {
+      result = this.interpreter.visitNode(statement);
+      if (result instanceof ReturnValue) {
+        return result.value;
+      }
+    }
+    return result;
+  }
+}

package/interpreter/executors/ControlFlowExecutor.js

@@ -0,0 +1,206 @@
+import { ErrorHandler } from "../ErrorHandler.js";
+import { Environment } from "../environment.js";
+import { isTruthy, stringify } from "../Utils.js";
+import { BreakException, ContinueException, ReturnValue } from "../Values.js";
+import { BaseExecutor } from "./BaseExecutor.js";
+import { MimoError } from "../MimoError.js";
+
+export class ControlFlowExecutor extends BaseExecutor {
+  executeIfStatement(node) {
+    const condition = this.interpreter.visitNode(node.condition);
+
+    if (isTruthy(condition)) {
+      // Create new block scope for consequent
+      const blockEnv = new Environment(this.interpreter.currentEnv);
+      return this.interpreter.executeBlock(node.consequent, blockEnv);
+    }
+
+    if (node.alternate) {
+      if (node.alternate.type === "IfStatement") {
+        return this.interpreter.visitNode(node.alternate);
+      } else {
+        const blockEnv = new Environment(this.interpreter.currentEnv);
+        return this.interpreter.executeBlock(node.alternate, blockEnv);
+      }
+    }
+
+    return null;
+  }
+
+  executeGuardStatement(node) {
+    const condition = this.interpreter.visitNode(node.condition);
+
+    // If the condition is met, do nothing (continue execution sequentially)
+    if (isTruthy(condition)) {
+      return null;
+    }
+
+    // Execute the alternate (else) block
+    const blockEnv = new Environment(this.interpreter.currentEnv);
+    const result = this.interpreter.executeBlock(node.alternate, blockEnv);
+
+    // Check if the else block terminated execution correctly
+    // It should either return a ReturnValue, or throw a BreakException/ContinueException/MimoError.
+    // If it reaches this point without doing so, it means the guard block didn't properly exit or the result wasn't a return.
+    if (!(result instanceof ReturnValue)) {
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `A guard statement's 'else' block must terminate execution (e.g., via return, throw, break, or continue).`,
+        node.alternate[node.alternate.length - 1] || node, // point to last statement or guard itself
+        "CTRL001",
+        "Add a return, throw, break, or continue statement to the end of the guard's else block."
+      );
+    }
+
+    return result; // returning the ReturnValue effectively terminates the current block
+  }
+
+  executeWhileStatement(node) {
+    let result = null;
+    while (isTruthy(this.interpreter.visitNode(node.condition))) {
+      try {
+        // Create new block scope for each iteration
+        const blockEnv = new Environment(this.interpreter.currentEnv);
+        result = this.interpreter.executeBlock(node.body, blockEnv);
+        if (result instanceof ReturnValue) {
+          return result;
+        }
+      } catch (exception) {
+        if (exception instanceof BreakException) {
+          if (exception.label && exception.label !== node.label) throw exception;
+          break;
+        }
+        if (exception instanceof ContinueException) {
+          if (exception.label && exception.label !== node.label) throw exception;
+          continue;
+        }
+        throw exception;
+      }
+    }
+    return result;
+  }
+
+  executeForStatement(node) {
+    const iterable = this.interpreter.visitNode(node.iterable);
+    if (!Array.isArray(iterable)) {
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `For loop requires an iterable (array). Got '${typeof iterable}'.`,
+        node.iterable,
+        "TYPE001",
+        'Ensure the expression after "in" is an array.',
+        this.interpreter.callStack
+      );
+    }
+
+    const previousEnv = this.interpreter.currentEnv;
+    this.interpreter.currentEnv = new Environment(previousEnv);
+
+    let result = null;
+    try {
+      for (const item of iterable) {
+        try {
+          // Create a new block scope for each iteration
+          const iterationEnv = new Environment(this.interpreter.currentEnv);
+          iterationEnv.define(node.variable.name, item);
+          result = this.interpreter.executeBlock(node.body, iterationEnv);
+          if (result instanceof ReturnValue) {
+            return result;
+          }
+        } catch (exception) {
+          if (exception instanceof BreakException) {
+            if (exception.label && exception.label !== node.label) throw exception;
+            break;
+          }
+          if (exception instanceof ContinueException) {
+            if (exception.label && exception.label !== node.label) throw exception;
+            continue;
+          }
+          throw exception;
+        }
+      }
+    } finally {
+      this.interpreter.currentEnv = previousEnv;
+    }
+    return result;
+  }
+
+  executeLoopStatement(node) {
+    let result = null;
+    while (true) {
+      try {
+        // Create new block scope for each iteration
+        const blockEnv = new Environment(this.interpreter.currentEnv);
+        result = this.interpreter.executeBlock(node.body, blockEnv);
+        if (result instanceof ReturnValue) {
+          return result;
+        }
+      } catch (exception) {
+        if (exception instanceof BreakException) {
+          if (exception.label && exception.label !== node.label) throw exception;
+          break;
+        }
+        if (exception instanceof ContinueException) {
+          if (exception.label && exception.label !== node.label) throw exception;
+          continue;
+        }
+        throw exception;
+      }
+    }
+    return result;
+  }
+
+  executeBreakStatement(node) {
+    throw new BreakException(node.label);
+  }
+
+  executeContinueStatement(node) {
+    throw new ContinueException(node.label);
+  }
+
+  executeTryStatement(node) {
+    try {
+      // Create new block scope for try block
+      const tryEnv = new Environment(this.interpreter.currentEnv);
+      return this.interpreter.executeBlock(node.tryBlock, tryEnv);
+    } catch (error) {
+      // Don't catch control flow exceptions or return values
+      if (
+        error instanceof BreakException ||
+        error instanceof ContinueException ||
+        error instanceof ReturnValue
+      ) {
+        throw error;
+      }
+
+      if (node.catchVar && node.catchBlock) {
+        // Create new block scope for catch block
+        const catchEnv = new Environment(this.interpreter.currentEnv);
+        // The caught error can be a MimoError or a raw JS Error
+        // We pass the MimoError object or a simplified string representation
+        // All errors caught by the try block (from Mimo code) should already be MimoErrors.
+        // If a raw JS error somehow propagates (which should be rare with Interpreter.interpret's wrapping),
+        // wrap it here too for consistency in the catch block.
+        const errorValue =
+          error instanceof MimoError
+            ? error
+            : this.interpreter.errorHandler.createRuntimeError(
+              `Unhandled JavaScript error: ${error.message}`,
+              node, // Use the try statement node for location if a raw JS error occurs
+              "INT005",
+              "An unexpected error occurred during execution. This indicates a bug in the Mimo interpreter, or an unhandled case. Please report this error."
+            );
+        catchEnv.define(node.catchVar.name, errorValue);
+        return this.interpreter.executeBlock(node.catchBlock, catchEnv);
+      }
+      // If no catch block, re-throw the error
+      throw error;
+    }
+  }
+
+  executeLabeledStatement(node) {
+    if (node.statement) {
+      node.statement.label = node.label;
+      return this.interpreter.statementExecutor.executeStatement(node.statement);
+    }
+    return null;
+  }
+}

package/interpreter/executors/FunctionExecutor.js

@@ -0,0 +1,126 @@
+import { BuiltinFunction } from "../BuiltinFunction.js";
+import { stringify } from "../Utils.js";
+import { FunctionValue, ReturnValue } from "../Values.js";
+import { BaseExecutor } from "./BaseExecutor.js";
+
+export class FunctionExecutor extends BaseExecutor {
+  executeFunctionDeclaration(node) {
+    let func = new FunctionValue(node, this.interpreter.currentEnv);
+
+    // Apply decorators in reverse order (bottom-up)
+    if (node.decorators && node.decorators.length > 0) {
+      for (let i = node.decorators.length - 1; i >= 0; i--) {
+        const decoratorNode = node.decorators[i];
+        const decorator = this.interpreter.visitNode(decoratorNode.name);
+
+        // Arity/Type check for decorator should ideally be here or inside FunctionValue.call
+        // For simplicity, we just call it.
+
+        if (decoratorNode.arguments) {
+          // Factory decorator: @retry(3)
+          const factoryArgs = decoratorNode.arguments.map(arg => this.interpreter.visitNode(arg));
+          const actualDecorator = decorator.call(this.interpreter, factoryArgs, decoratorNode);
+
+          if (typeof actualDecorator?.call !== 'function') {
+            throw this.interpreter.errorHandler.createRuntimeError(
+              `Decorator factory '${decoratorNode.name.name}' must return a callable function.`,
+              decoratorNode, 'DEC001'
+            );
+          }
+          func = actualDecorator.call(this.interpreter, [func], decoratorNode);
+        } else {
+          // Simple decorator: @log
+          func = decorator.call(this.interpreter, [func], decoratorNode);
+        }
+      }
+    }
+
+    this.interpreter.currentEnv.define(node.name, func);
+    return null;
+  }
+
+  executeCallStatement(node) {
+    // Evaluate the callee (could be identifier or module access)
+    let func;
+    let functionName;
+
+    if (typeof node.callee === "string") {
+      // Legacy support for string callee
+      func = this.interpreter.currentEnv.lookup(node.callee);
+      functionName = node.callee;
+    } else {
+      // New AST node callee (Identifier, ModuleAccess, or expression)
+      func = this.interpreter.visitNode(node.callee);
+      if (node.callee.type === "ModuleAccess") {
+        functionName = `${node.callee.module}.${node.callee.property}`;
+      } else if (node.callee.type === "Identifier") {
+        functionName = node.callee.name;
+      } else {
+        functionName = "<anonymous function>";
+      }
+    }
+
+    if (
+      !(func instanceof FunctionValue) &&
+      !(func instanceof BuiltinFunction)
+    ) {
+      throw this.interpreter.errorHandler.createRuntimeError(
+        `'${functionName}' is not a callable function.`,
+        node,
+        "TYPE002",
+        "Ensure you are calling a function or method."
+      );
+    }
+
+    const args = [];
+    for (const arg of node.arguments) {
+      if (arg.type === 'SpreadElement') {
+        const spreadValue = this.interpreter.visitNode(arg.argument);
+        if (!Array.isArray(spreadValue)) {
+          throw this.interpreter.errorHandler.createRuntimeError(
+            `Cannot spread non-array value in function call.`,
+            arg.argument,
+            'TYPE001'
+          );
+        }
+        args.push(...spreadValue);
+      } else {
+        args.push(this.interpreter.visitNode(arg));
+      }
+    }
+    const result = func.call(this.interpreter, args, node); // Directly call, pass node for location
+
+    if (node.destination) {
+      this.interpreter.currentEnv.define(node.destination.name, result);
+    }
+    return result;
+  }
+
+  executeReturnStatement(node) {
+    const value = node.argument
+      ? this.interpreter.visitNode(node.argument)
+      : null;
+    return new ReturnValue(value);
+  }
+
+  executeShowStatement(node) {
+    const value = this.interpreter.visitNode(node.expression);
+    const rendered = stringify(value);
+    if (this.interpreter.adapter && typeof this.interpreter.adapter.log === "function") {
+      this.interpreter.adapter.log(rendered);
+    } else {
+      console.log(rendered);
+    }
+    return value;
+  }
+
+  executeThrowStatement(node) {
+    const value = this.interpreter.visitNode(node.argument);
+    throw this.interpreter.errorHandler.createRuntimeError(
+      stringify(value),
+      node,
+      "USER001", // A code for user-thrown errors
+      'This error was thrown by the "throw" statement.'
+    );
+  }
+}