yukigo 0.2.3 → 0.3.2

package/src/interpreter/components/runtimes/ObjectRuntime.ts

@@ -1,224 +1,262 @@
-import {
-  PrimitiveValue,
-  RuntimeFunction,
-  RuntimeObject,
-  isRuntimeObject,
-  isRuntimeClass,
-  RuntimeClass,
-  EnvStack,
-} from "yukigo-ast";
-import { InterpreterError } from "../../errors.js";
-import { Continuation, Thunk } from "../../trampoline.js";
-import { RuntimeContext } from "../RuntimeContext.js";
-
-type OOPEntity = RuntimeClass | RuntimeObject;
-
-type OOPMatch = {
-  method: RuntimeFunction;
-  holder: RuntimeObject | RuntimeClass;
-};
-
-export class ObjectRuntime {
-  constructor(private context: RuntimeContext) {}
-  /**
-   * Creates a new instance of an Object.
-   * Typically called by visitNew()
-   */
-  public instantiate(
-    className: string,
-    identifier: string,
-    fieldDefinitions: Map<string, PrimitiveValue>,
-    methodDefinitions: Map<string, RuntimeFunction>,
-  ): RuntimeObject {
-    return {
-      type: "Object",
-      className,
-      identifier,
-      fields: new Map(fieldDefinitions),
-      methods: methodDefinitions,
-    };
-  }
-
-  /**
-   * Handles Method Calls (Message Passing).
-   * Reuses FunctionRuntime to execute the method body.
-   */
-  public dispatch(
-    receiver: PrimitiveValue,
-    methodName: string,
-    args: PrimitiveValue[],
-    env: EnvStack,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    if (!isRuntimeObject(receiver))
-      throw new Error(`${receiver} is not an object`);
-
-    const chain = this.getResolutionChain(receiver, env);
-    const match = this.findMethodInChain(chain, methodName);
-
-    if (!match)
-      throw new InterpreterError(
-        "MethodDispatch",
-        `${receiver.className} does not understand '${methodName}'.`,
-      );
-
-    const objectScope = this.createDispatchScope(receiver, match, methodName);
-    this.context.pushEnv(objectScope);
-    return this.context.funcRuntime.apply(match.method, args, k);
-  }
-
-  /**
-   * Handles calls to super() or super.method()
-   */
-  public dispatchSuper(
-    currentEnv: EnvStack,
-    methodName: string,
-    args: PrimitiveValue[],
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    const self = this.context.lookup("self") as RuntimeObject;
-    const currentHolder = this.context.lookup("__CONTEXT_CLASS__") as OOPEntity;
-    const currentMethodName = this.context.lookup("__METHOD_NAME__");
-    const targetMethodName = methodName || currentMethodName;
-
-    if (!self || !currentHolder)
-      throw new InterpreterError(
-        "SuperError",
-        "'super' used outside of a method context",
-      );
-
-    const chain = this.getResolutionChain(self, currentEnv);
-
-    const currentIndex = chain.findIndex((c) => c === currentHolder);
-
-    if (currentIndex === -1)
-      throw new Error("Fatal: Execution context not found in hierarchy chain");
-
-    const remainingChain = chain.slice(currentIndex + 1);
-    const match = this.findMethodInChain(remainingChain, methodName);
-
-    if (!match)
-      throw new InterpreterError(
-        "Super",
-        `Super method '${methodName}' not found`,
-      );
-
-    const objectScope = this.createDispatchScope(self, match, targetMethodName);
-
-    this.context.pushEnv(objectScope);
-    return this.context.funcRuntime.apply(match.method, args, k);
-  }
-  private createDispatchScope(
-    self: RuntimeObject,
-    match: OOPMatch,
-    targetName: PrimitiveValue,
-  ) {
-    const objectScope = new Map<string, PrimitiveValue>();
-    objectScope.set("self", self);
-    objectScope.set("__CONTEXT_CLASS__", match.holder);
-    objectScope.set("__METHOD_NAME__", targetName);
-
-    for (const [key, val] of self.fields) objectScope.set(key, val);
-    return objectScope;
-  }
-  private getResolutionChain(
-    receiver: RuntimeObject,
-    env: EnvStack,
-  ): Array<RuntimeObject | RuntimeClass> {
-    const chain: Array<RuntimeObject | RuntimeClass> = [];
-
-    chain.push(receiver);
-
-    if (receiver.className) {
-      this.expandClassHierarchy(receiver.className, env, chain);
-    }
-
-    return chain;
-  }
-  private expandClassHierarchy(
-    className: string,
-    env: EnvStack,
-    chain: Array<RuntimeObject | RuntimeClass>,
-  ) {
-    const classDef = this.context.lookup(className);
-    if (!isRuntimeClass(classDef))
-      throw new InterpreterError(
-        "expandClassHierarchy",
-        "classDef was expected to be a RuntimeClass",
-      );
-
-    chain.push(classDef);
-
-    const classDefCopy = [...classDef.mixins];
-
-    if (classDef.mixins)
-      classDefCopy.reverse().forEach((mixinName) => {
-        this.expandClassHierarchy(mixinName, env, chain);
-      });
-
-    if (classDef.superclass)
-      this.expandClassHierarchy(classDef.superclass, env, chain);
-  }
-  private findMethodInChain(
-    chain: Array<RuntimeObject | RuntimeClass>,
-    methodName: string,
-  ): OOPMatch | undefined {
-    for (const link of chain) {
-      if (link.methods.has(methodName))
-        return {
-          method: link.methods.get(methodName)!,
-          holder: link,
-        };
-    }
-    return undefined;
-  }
-
-  /**
-   * Field Access (Get)
-   * e.g. self.myField
-   */
-  public getField(receiver: PrimitiveValue, fieldName: string): PrimitiveValue {
-    if (!isRuntimeObject(receiver))
-      throw new InterpreterError("FieldAccess", "Target is not an object");
-
-    if (!receiver.fields.has(fieldName)) {
-      if (receiver.methods.has(fieldName))
-        return receiver.methods.get(fieldName);
-
-      throw new InterpreterError(
-        "FieldAccess",
-        `Field '${fieldName}' not found in ${receiver.className}`,
-      );
-    }
-
-    return receiver.fields.get(fieldName);
-  }
-
-  /**
-   * Field Mutation (Set)
-   * e.g. self.myField = 10
-   */
-  public setField(
-    receiver: PrimitiveValue,
-    fieldName: string,
-    value: PrimitiveValue,
-  ): PrimitiveValue {
-    if (!this.context.config.mutability)
-      throw new InterpreterError(
-        "FieldAssignment",
-        `Cannot mutate field '${fieldName}': mutability is disabled`,
-      );
-
-    if (!isRuntimeObject(receiver))
-      throw new InterpreterError("FieldAssignment", "Target is not an object");
-
-    if (!receiver.fields.has(fieldName))
-      throw new InterpreterError(
-        "FieldAssignment",
-        `Cannot set unknown field '${fieldName}'`,
-      );
-
-    receiver.fields.set(fieldName, value);
-    return value;
-  }
-}
+import { InterpreterError } from "../../errors.js";
+import {
+  YuValue,
+  RuntimeClass,
+  RuntimeObject,
+  RuntimeFunction,
+  isRuntimeObject,
+  YuString,
+  isRuntimeClass,
+  YuBoolean,
+  YuArray,
+  YuNumber,
+  YuNil,
+} from "../../primitives/index.js";
+import { error, raise } from "../../utils.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import {
+  ExecutionCommand,
+  BindCommand,
+  StepCommand,
+  RaiseCommand,
+} from "../kernel/commands.js";
+
+type OOPEntity = RuntimeClass | RuntimeObject;
+
+type OOPMatch = {
+  method: RuntimeFunction;
+  holder: RuntimeObject | RuntimeClass;
+};
+
+export class ObjectRuntime {
+  constructor(private context: RuntimeContext) {}
+  /**
+   * Handles Method Calls (Message Passing).
+   * Reuses FunctionRuntime to execute the method body.
+   */
+  public dispatch(
+    receiver: YuValue,
+    methodName: string,
+    args: YuValue[],
+  ): ExecutionCommand {
+    if (!isRuntimeObject(receiver)) {
+      return this.dispatchPrimitive(receiver, methodName, args);
+    }
+
+    const chain = this.getResolutionChain(receiver);
+
+    const arity = args.length;
+    const arityKey = `${methodName}/${arity}`;
+    let match = this.findMethodInChain(chain, arityKey);
+    
+    if (!match) {
+      match = this.findMethodInChain(chain, methodName);
+    }
+
+    if (!match) {
+      if (methodName === "toString") {
+        return new StepCommand(new YuString(receiver.toString()));
+      }
+      if (methodName === "error") {
+        const errorMsg = args[0] ? args[0].toString() : "An error occurred";
+        return new RaiseCommand(new InterpreterError("Raise", errorMsg));
+      }
+      return raise(
+        error(
+          "MethodDispatch",
+          `${receiver.className} does not understand '${methodName}'.`,
+        ),
+      );
+    }
+
+    const objectScope = receiver.createDispatchScope(
+      match,
+      new YuString(methodName),
+    );
+    this.context.pushEnv(objectScope);
+    return new BindCommand(
+      this.context.funcRuntime.apply(match.method, args),
+      (res) => {
+        this.context.popEnv();
+        return new StepCommand(res);
+      },
+    );
+  }
+
+  /**
+   * Handles calls to super() or super.method()
+   */
+  public dispatchSuper(methodName: string, args: YuValue[]): ExecutionCommand {
+    const self = this.context.lookup("self") as RuntimeObject;
+    const currentHolder = this.context.lookup("__CONTEXT_CLASS__") as OOPEntity;
+    const currentMethodName = this.context.lookup("__METHOD_NAME__");
+
+    if (!self || !currentHolder)
+      return raise(
+        error("dispatchSuper", "'super' used outside of a method context"),
+      );
+
+    const chain = this.getResolutionChain(self);
+    const currentIndex = chain.findIndex((c) => c === currentHolder);
+
+    if (currentIndex === -1)
+      return raise(
+        error(
+          "dispatchSuper",
+          "Execution context not found in hierarchy chain",
+        ),
+      );
+
+    const remainingChain = chain.slice(currentIndex + 1);
+
+    const baseName = methodName || (currentMethodName as YuString).toJSON();
+    const arityKey = `${baseName}/${args.length}`;
+
+    let match = this.findMethodInChain(remainingChain, arityKey);
+
+    // Fallback: si no encuentra con aridad, buscar solo por nombre (para compatibilidad)
+    if (!match && methodName) {
+      match = this.findMethodInChain(remainingChain, methodName);
+    }
+    if (!match && !methodName) {
+      match = this.findMethodInChain(
+        remainingChain,
+        (currentMethodName as YuString).toJSON(),
+      );
+    }
+
+    if (!match)
+      return raise(error("Super", `Super method '${baseName}' not found`));
+
+    const objectScope = self.createDispatchScope(match, new YuString(baseName));
+    this.context.pushEnv(objectScope);
+
+    return new BindCommand(
+      this.context.funcRuntime.apply(match.method, args),
+      (res) => {
+        this.context.popEnv();
+        return new StepCommand(res);
+      },
+    );
+  }
+
+  public getResolutionChain(receiver: RuntimeObject): OOPEntity[] {
+    const chain: OOPEntity[] = [receiver];
+
+    if (receiver.className) {
+      const hierarchy = this.expandClassHierarchy(receiver.className);
+      chain.push(...hierarchy);
+    }
+
+    return chain;
+  }
+  private expandClassHierarchy(className: string): OOPEntity[] {
+    const chain: OOPEntity[] = [];
+    const visited = new Set<string>();
+    const queue = [className];
+
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      // occurs check to avoid circular loops
+      if (visited.has(current)) continue;
+      visited.add(current);
+
+      const classDef = this.getClassDef(current);
+      chain.push(classDef);
+      queue.push(...classDef.getHierarchy());
+    }
+
+    return chain;
+  }
+  private getClassDef(name: string): RuntimeClass {
+    const classDef = this.context.lookup(name);
+    if (!isRuntimeClass(classDef))
+      throw error(
+        "expandClassHierarchy",
+        "classDef was expected to be a RuntimeClass",
+      );
+    return classDef;
+  }
+
+  public findMethodInChain(
+    chain: Array<OOPEntity>,
+    methodName: string,
+  ): OOPMatch | undefined {
+    const match = chain.find((def) => def.methods.has(methodName));
+    if (!match) return undefined;
+    return {
+      method: match.methods.get(methodName)!,
+      holder: match,
+    };
+  }
+
+  /**
+   * Field Access (Get)
+   * e.g. self.myField
+   */
+  public getField(receiver: YuValue, fieldName: string): YuValue {
+    if (!isRuntimeObject(receiver))
+      throw new InterpreterError("FieldAccess", "Target is not an object");
+
+    if (receiver.hasMethod(fieldName)) return receiver.getMethod(fieldName);
+    return receiver.getField(fieldName);
+  }
+
+  /**
+   * Field Mutation (Set)
+   * e.g. self.myField = 10
+   */
+  public setField(obj: YuValue, fieldName: string, value: YuValue): YuValue {
+    if (!this.context.config.mutability)
+      throw new InterpreterError(
+        "FieldAssignment",
+        `Cannot mutate field '${fieldName}': mutability is disabled`,
+      );
+
+    const receiver = this.getReceiver(obj);
+
+    if (!isRuntimeObject(receiver))
+      throw new InterpreterError("FieldAssignment", "Target is not an object");
+
+    receiver.setField(fieldName, value);
+    return new YuBoolean(true);
+  }
+
+  private getReceiver(obj: YuValue): OOPEntity {
+    if (isRuntimeObject(obj) || isRuntimeClass(obj)) return obj;
+    throw new InterpreterError(
+      "ObjectRuntime",
+      "Receiver is not an OOP entity",
+    );
+  }
+
+  public dispatchPrimitive(
+    receiver: YuValue,
+    methodName: string,
+    args: YuValue[],
+  ): ExecutionCommand {
+    if (!receiver || receiver.isNil)
+      return new StepCommand(YuNil.getInstance());
+    // Obtenemos el identificador polimórfico del tipo (ej: "YuArray", "YuNumber", "YuString", "RuntimeFunction")
+    const typeKey = receiver.constructor.name;
+    const lookupKey = `${typeKey}.${methodName}`;
+
+    // Buscamos si el ecosistema/lenguaje proveyó una implementación externa para este caso
+    const nativeImpl = this.context.config.nativeProviders.get(lookupKey);
+
+    if (nativeImpl) {
+      // Delegamos la subtarea de forma declarativa pasándole el receptor como contexto
+      return new BindCommand(
+        nativeImpl(receiver, args, this.context),
+        (res) => new StepCommand(res),
+      );
+    }
+
+    return raise(
+      error(
+        "ObjectRuntime.dispatch",
+        `Primitive type '${typeKey}' does not understand method '${methodName}'.`,
+      ),
+    );
+  }
+}

package/src/interpreter/errors.ts

@@ -1,47 +1,68 @@
-import { SourceLocation } from "yukigo-ast";
-
-export interface ErrorFrame {
-  nodeType: string;
-  loc?: SourceLocation;
-}
-
-export class InterpreterError extends Error {
-  context: string;
-  frames: ErrorFrame[];
-
-  constructor(context: string, message: string, frames: ErrorFrame[] = []) {
-    super(`[${context}] ${message}`);
-    this.context = context;
-    this.frames = frames;
-  }
-
-  pushFrame(frame: ErrorFrame) {
-    this.frames.push(frame);
-  }
-
-  formatStack(): string {
-    if (!this.frames.length) return "";
-    const formatted = this.frames
-      .map((f) => {
-        const loc = f.loc ? ` (line ${f.loc.line}, col ${f.loc.column})` : "";
-        return `  • ${f.nodeType}${loc}`;
-      })
-      .join("\n");
-    return `\nTrace:\n${formatted}`;
-  }
-
-  override toString(): string {
-    return `${this.message}${this.formatStack()}`;
-  }
-}
-export class UnexpectedValue extends InterpreterError {
-  constructor(ctx: string, expected: string, got: string) {
-    super(ctx, `Expected ${expected} but got ${got}`);
-  }
-}
-
-export class UnboundVariable extends Error {
-  constructor(name: string) {
-    super(`Unbound variable: ${name}`);
-  }
-}
+import { SourceLocation } from "yukigo-ast";
+import { YuValue } from "./primitives/YuValue.js";
+
+export interface ErrorFrame {
+  nodeType: string;
+  loc?: SourceLocation;
+}
+
+export class InterpreterError extends Error {
+  context: string;
+  frames: ErrorFrame[];
+
+  constructor(context: string, message: string, frames: ErrorFrame[] = []) {
+    super(`[${context}] ${message}`);
+    this.context = context;
+    this.frames = frames;
+    this.name = "InterpreterError";
+  }
+
+  pushFrame(frame: ErrorFrame) {
+    this.frames.push(frame);
+  }
+
+  formatStack(): string {
+    if (!this.frames.length) return "";
+    const formatted = this.frames
+      .map((f) => {
+        const loc = f.loc ? ` (line ${f.loc.line}, col ${f.loc.column})` : "";
+        return `  • ${f.nodeType}${loc}`;
+      })
+      .join("\n");
+    return `\nTrace:\n${formatted}`;
+  }
+
+  override toString(): string {
+    return `${this.message}${this.formatStack()}`;
+  }
+}
+
+export class UnexpectedNode extends InterpreterError {
+  constructor(nodeCons: string, context: string) {
+    super(context, `${nodeCons} not expected in ${context}.`);
+    this.name = "UnexpectedNode";
+  }
+}
+export class UnexpectedValue extends InterpreterError {
+  constructor(ctx: string, expected: string, got: string) {
+    super(ctx, `Expected ${expected} but got ${got}`);
+  }
+}
+
+export class UnboundVariable extends Error {
+  constructor(name: string) {
+    super(`Unbound variable: ${name}`);
+  }
+}
+
+export class NotConcatenable extends InterpreterError {
+  constructor() {
+    super("[Concat]", "Cannot concat non-concatenable types.");
+  }
+}
+
+export class UnsupportedOperation extends InterpreterError {
+  constructor(val: YuValue, op: string) {
+    super("[Unsupported]", `${val.getType()} does not support '${op}'`);
+  }
+}