@lewin671/python-vm 0.1.0 → 0.1.2

package/src/vm/builtins.ts

@@ -1,237 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { PyClass, PyDict, PyException, PyFile, PyGenerator, Scope } from './runtime-types';
-import { isFloatLike, isNumericLike, pyStr, pyTypeName, toBigIntValue, toNumber } from './value-utils';
-
-export function installBuiltins(this: VirtualMachine, scope: Scope) {
-  const builtins = new Map<string, any>();
-  builtins.set('print', (...args: any[]) => {
-    let sep = ' ';
-    let end = '\n';
-    if (args.length > 0) {
-      const last = args[args.length - 1];
-      if (last && last.__kwargs__) {
-        const kwargs = last.__kwargs__;
-        sep = kwargs.sep !== undefined ? kwargs.sep : sep;
-        end = kwargs.end !== undefined ? kwargs.end : end;
-        args = args.slice(0, -1);
-      }
-    }
-    const output = args.map((a) => pyStr(a)).join(sep) + end;
-    process.stdout.write(output);
-    return null;
-  });
-  builtins.set('len', (value: any) => {
-    if (typeof value === 'string' || Array.isArray(value)) return value.length;
-    if (value instanceof PyDict || value instanceof Set) return value.size;
-    throw new PyException('TypeError', 'object has no len()');
-  });
-  builtins.set('range', (...args: any[]) => {
-    let start = 0;
-    let end = 0;
-    let step = 1;
-    if (args.length === 1) {
-      end = toNumber(args[0]);
-    } else if (args.length === 2) {
-      start = toNumber(args[0]);
-      end = toNumber(args[1]);
-    } else if (args.length >= 3) {
-      start = toNumber(args[0]);
-      end = toNumber(args[1]);
-      step = toNumber(args[2]);
-    }
-    const result: number[] = [];
-    if (step === 0) throw new PyException('ValueError', 'range() arg 3 must not be zero');
-    if (step > 0) {
-      for (let i = start; i < end; i += step) result.push(i);
-    } else {
-      for (let i = start; i > end; i += step) result.push(i);
-    }
-    return result;
-  });
-  const listFn = (value: any) => {
-    if (Array.isArray(value)) return [...value];
-    if (value instanceof Set) return Array.from(value.values());
-    if (value && typeof value[Symbol.iterator] === 'function') return Array.from(value);
-    return [];
-  };
-  (listFn as any).__typeName__ = 'list';
-  builtins.set('list', listFn);
-  const tupleFn = (value: any) => {
-    const arr = Array.isArray(value) ? [...value] : value && typeof value[Symbol.iterator] === 'function' ? Array.from(value) : [];
-    (arr as any).__tuple__ = true;
-    return arr;
-  };
-  (tupleFn as any).__typeName__ = 'tuple';
-  builtins.set('tuple', tupleFn);
-  const setFn = (value: any) => {
-    if (value instanceof Set) return new Set(value);
-    if (Array.isArray(value)) return new Set(value);
-    if (value && typeof value[Symbol.iterator] === 'function') return new Set(Array.from(value));
-    return new Set();
-  };
-  (setFn as any).__typeName__ = 'set';
-  builtins.set('set', setFn);
-  builtins.set('sum', (value: any[]) => {
-    if (value.some((v) => typeof v === 'bigint')) {
-      return value.reduce((acc, v) => acc + toBigIntValue(v), 0n);
-    }
-    return value.reduce((acc, v) => acc + v, 0);
-  });
-  builtins.set('max', (...args: any[]) => {
-    const values = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-    if (values.every((v: any) => isNumericLike(v) && !isFloatLike(v))) {
-      return values.reduce((acc: any, v: any) => (toBigIntValue(v) > toBigIntValue(acc) ? v : acc));
-    }
-    return Math.max(...values.map((v: any) => toNumber(v)));
-  });
-  builtins.set('min', (...args: any[]) => {
-    const values = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
-    if (values.every((v: any) => isNumericLike(v) && !isFloatLike(v))) {
-      return values.reduce((acc: any, v: any) => (toBigIntValue(v) < toBigIntValue(acc) ? v : acc));
-    }
-    return Math.min(...values.map((v: any) => toNumber(v)));
-  });
-  builtins.set('abs', (value: any) => {
-    if (typeof value === 'bigint') return value < 0n ? -value : value;
-    return Math.abs(toNumber(value));
-  });
-  const roundHalfToEven = (input: number) => {
-    const floored = Math.floor(input);
-    const diff = input - floored;
-    const epsilon = 1e-12;
-    if (diff > 0.5 + epsilon) return floored + 1;
-    if (diff < 0.5 - epsilon) return floored;
-    return floored % 2 === 0 ? floored : floored + 1;
-  };
-  builtins.set('round', (value: number, digits?: number) => {
-    if (digits === undefined) return roundHalfToEven(value);
-    const factor = Math.pow(10, digits);
-    return roundHalfToEven(value * factor) / factor;
-  });
-  const intFn = (value: any) => {
-    if (typeof value === 'bigint') return value;
-    const text = typeof value === 'string' ? value.trim() : null;
-    if (text && /^[-+]?\\d+$/.test(text)) {
-      const big = BigInt(text);
-      const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
-      const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
-      if (big > maxSafe || big < minSafe) {
-        return big;
-      }
-    }
-    const result = parseInt(value, 10);
-    if (Number.isNaN(result)) throw new PyException('ValueError', 'Invalid integer');
-    const boxed = new Number(result);
-    (boxed as any).__int__ = true;
-    return boxed;
-  };
-  (intFn as any).__typeName__ = 'int';
-  builtins.set('int', intFn);
-  const floatFn = (value?: any) => {
-    if (value === undefined) return new Number(0);
-    if (value instanceof Number) return new Number(value.valueOf());
-    if (typeof value === 'number') return new Number(value);
-    if (typeof value === 'boolean') return new Number(value ? 1 : 0);
-    if (typeof value === 'string') {
-      const text = value.trim();
-      if (text.length === 0) throw new PyException('ValueError', 'Invalid float');
-      const lower = text.toLowerCase();
-      if (lower === 'nan' || lower === '+nan' || lower === '-nan') return new Number(NaN);
-      if (lower === 'inf' || lower === '+inf' || lower === 'infinity' || lower === '+infinity') return new Number(Infinity);
-      if (lower === '-inf' || lower === '-infinity') return new Number(-Infinity);
-      const result = parseFloat(text);
-      if (Number.isNaN(result)) throw new PyException('ValueError', 'Invalid float');
-      return new Number(result);
-    }
-    const result = parseFloat(value);
-    if (Number.isNaN(result)) throw new PyException('ValueError', 'Invalid float');
-    return new Number(result);
-  };
-  (floatFn as any).__typeName__ = 'float';
-  builtins.set('float', floatFn);
-  const strFn = (value: any) => pyStr(value);
-  (strFn as any).__typeName__ = 'str';
-  builtins.set('str', strFn);
-  const boolFn = (value: any) => this.isTruthy(value, scope);
-  (boolFn as any).__typeName__ = 'bool';
-  builtins.set('bool', boolFn);
-  builtins.set('type', (value: any) => ({ __typeName__: pyTypeName(value) }));
-  builtins.set('isinstance', (value: any, typeObj: any) => {
-    if (typeObj && typeObj.__typeName__) {
-      return pyTypeName(value) === typeObj.__typeName__;
-    }
-    return false;
-  });
-  builtins.set('enumerate', (iterable: any) => {
-    const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
-    return arr.map((v, i) => {
-      const tup = [i, v];
-      (tup as any).__tuple__ = true;
-      return tup;
-    });
-  });
-  builtins.set('zip', (...iterables: any[]) => {
-    const arrays = iterables.map((it) => (Array.isArray(it) ? it : Array.from(it)));
-    const length = Math.min(...arrays.map((a) => a.length));
-    const result: any[] = [];
-    for (let i = 0; i < length; i++) {
-      const tup = arrays.map((a) => a[i]);
-      (tup as any).__tuple__ = true;
-      result.push(tup);
-    }
-    return result;
-  });
-  builtins.set('sorted', (iterable: any) => {
-    const arr = Array.isArray(iterable) ? [...iterable] : Array.from(iterable);
-    if (arr.every((v) => isNumericLike(v))) {
-      return arr.sort((a, b) => toNumber(a) - toNumber(b));
-    }
-    return arr.sort();
-  });
-  builtins.set('reversed', (iterable: any) => {
-    const arr = Array.isArray(iterable) ? [...iterable] : Array.from(iterable);
-    return arr.reverse();
-  });
-  builtins.set('map', (fn: any, iterable: any) => {
-    const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
-    return arr.map((value) => this.callFunction(fn, [value], scope));
-  });
-  builtins.set('filter', (fn: any, iterable: any) => {
-    const arr = Array.isArray(iterable) ? iterable : Array.from(iterable);
-    return arr.filter((value) => this.isTruthy(this.callFunction(fn, [value], scope), scope));
-  });
-  builtins.set('next', (iterable: any) => {
-    if (iterable instanceof PyGenerator) {
-      return iterable.next();
-    }
-    if (iterable && typeof iterable.next === 'function') {
-      const result = iterable.next();
-      if (result.done) throw new PyException('StopIteration', 'StopIteration');
-      return result.value;
-    }
-    throw new PyException('TypeError', 'object is not an iterator');
-  });
-  builtins.set('open', (path: any, mode: any = 'r') => {
-    const file = new PyFile(String(path), String(mode));
-    try {
-      file.open();
-    } catch (err) {
-      throw new PyException('FileNotFoundError', 'File not found');
-    }
-    return file;
-  });
-  const exceptionClass = (name: string, base?: PyClass) => {
-    const klass = new PyClass(name, base ? [base] : [], new Map(), true);
-    return klass;
-  };
-
-  const ExceptionBase = exceptionClass('Exception');
-  builtins.set('Exception', ExceptionBase);
-  builtins.set('AssertionError', exceptionClass('AssertionError', ExceptionBase));
-  builtins.set('ZeroDivisionError', exceptionClass('ZeroDivisionError', ExceptionBase));
-  builtins.set('ValueError', exceptionClass('ValueError', ExceptionBase));
-  builtins.set('TypeError', exceptionClass('TypeError', ExceptionBase));
-  builtins.set('FileNotFoundError', exceptionClass('FileNotFoundError', ExceptionBase));
-
-  scope.values = new Map([...builtins.entries()]);
-}

package/src/vm/callable.ts

@@ -1,154 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { ASTNodeType } from '../types';
-import { PyClass, PyDict, PyException, PyFunction, PyGenerator, PyInstance, ReturnSignal, Scope } from './runtime-types';
-
-export function callFunction(
-  this: VirtualMachine,
-  func: any,
-  args: any[],
-  scope: Scope,
-  kwargs: Record<string, any> = {}
-): any {
-  if (!kwargs) {
-    kwargs = {};
-  }
-  if (func instanceof PyFunction) {
-    const callScope = new Scope(func.closure);
-    for (const param of func.params) {
-      if (param.type === 'Param') {
-        let argValue: any;
-        if (args.length > 0) {
-          argValue = args.shift();
-        } else if (param.name in kwargs) {
-          argValue = kwargs[param.name];
-          delete kwargs[param.name];
-        } else if (param.defaultEvaluated !== undefined) {
-          argValue = param.defaultEvaluated;
-        } else if (param.defaultValue) {
-          argValue = this.evaluateExpression(param.defaultValue, scope);
-        } else {
-          argValue = null;
-        }
-        callScope.set(param.name, argValue);
-      } else if (param.type === 'VarArg') {
-        const varArgs = [...args];
-        (varArgs as any).__tuple__ = true;
-        callScope.set(param.name, varArgs);
-        args = [];
-      } else if (param.type === 'KwArg') {
-        const kwDict = new PyDict();
-        for (const [key, value] of Object.entries(kwargs)) {
-          kwDict.set(key, value);
-        }
-        callScope.set(param.name, kwDict);
-        kwargs = {};
-      }
-    }
-    try {
-      if (func.isGenerator) {
-        const iterator = this.executeBlockGenerator(func.body, callScope);
-        return new PyGenerator(iterator);
-      }
-      const result = this.executeBlock(func.body, callScope);
-      return result;
-    } catch (err) {
-      if (err instanceof ReturnSignal) return err.value;
-      throw err;
-    }
-  }
-  if (func instanceof PyClass) {
-    const instance = new PyInstance(func);
-    if (func.isException && args.length > 0) {
-      instance.attributes.set('message', args[0]);
-    }
-    const init = this.findClassAttribute(func, '__init__');
-    if (init instanceof PyFunction) {
-      this.callFunction(init, [instance, ...args], scope, kwargs);
-    }
-    return instance;
-  }
-  if (typeof func === 'function') {
-    if (Object.keys(kwargs).length > 0) {
-      return func(...args, { __kwargs__: kwargs });
-    }
-    return func(...args);
-  }
-  throw new PyException('TypeError', 'object is not callable');
-}
-
-export function containsYield(this: VirtualMachine, body: any[]): boolean {
-  for (const stmt of body) {
-    if (stmt.type === ASTNodeType.YIELD) return true;
-    if (stmt.expression && this.expressionHasYield(stmt.expression)) return true;
-    if (stmt.value && this.expressionHasYield(stmt.value)) return true;
-    if (stmt.body && Array.isArray(stmt.body) && this.containsYield(stmt.body)) return true;
-  }
-  return false;
-}
-
-export function evaluateComprehension(this: VirtualMachine, node: any, scope: Scope, emit: () => void) {
-  const clauses = node.clauses || [];
-  const walk = (index: number) => {
-    if (index >= clauses.length) {
-      emit();
-      return;
-    }
-    const clause = clauses[index];
-    const iterable = this.evaluateExpression(clause.iter, scope);
-    const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
-    for (const item of items) {
-      this.assignTarget(clause.target, item, scope);
-      const passes = clause.ifs.every((cond: any) => this.isTruthy(this.evaluateExpression(cond, scope), scope));
-      if (passes) {
-        walk(index + 1);
-      }
-    }
-  };
-  walk(0);
-}
-
-export function* generateComprehension(
-  this: VirtualMachine,
-  node: any,
-  scope: Scope,
-  valueFactory: () => any
-): Generator<any, any, any> {
-  const clauses = node.clauses || [];
-  const walk = (index: number): Generator<any, any, any> => {
-    const self = this;
-    return (function* (): Generator<any, any, any> {
-      if (index >= clauses.length) {
-        yield valueFactory();
-        return;
-      }
-      const clause = clauses[index];
-      const iterable = self.evaluateExpression(clause.iter, scope);
-      const items = Array.isArray(iterable) ? iterable : Array.from(iterable);
-      for (const item of items) {
-        self.assignTarget(clause.target, item, scope);
-        const passes = clause.ifs.every((cond: any) => self.isTruthy(self.evaluateExpression(cond, scope), scope));
-        if (passes) {
-          yield* walk(index + 1);
-        }
-      }
-    })();
-  };
-  yield* walk(0);
-  return null;
-}
-
-export function expressionHasYield(this: VirtualMachine, node: any): boolean {
-  if (!node) return false;
-  if (node.type === ASTNodeType.YIELD) return true;
-  for (const key of Object.keys(node)) {
-    const value = (node as any)[key];
-    if (Array.isArray(value)) {
-      if (value.some((item) => item && typeof item === 'object' && this.expressionHasYield(item))) {
-        return true;
-      }
-    } else if (value && typeof value === 'object') {
-      if (this.expressionHasYield(value)) return true;
-    }
-  }
-  return false;
-}

package/src/vm/execution.ts

@@ -1,251 +0,0 @@
-import type { VirtualMachine } from './vm';
-import { ByteCode, ASTNodeType } from '../types';
-import { BreakSignal, ContinueSignal, ReturnSignal, Scope } from './runtime-types';
-import { PyDict } from './runtime-types';
-
-export function execute(this: VirtualMachine, bytecode: ByteCode): any {
-  if (!bytecode.ast) {
-    throw new Error('Bytecode missing AST');
-  }
-
-  const globalScope = new Scope();
-  this.installBuiltins(globalScope);
-  return this.executeBlock(bytecode.ast.body, globalScope);
-}
-
-export function executeBlock(this: VirtualMachine, body: any[], scope: Scope): any {
-  let lastValue: any = null;
-  for (const stmt of body) {
-    lastValue = this.executeStatement(stmt, scope);
-  }
-  return lastValue;
-}
-
-export function iterableToArray(this: VirtualMachine, iterable: any): any[] {
-  if (iterable instanceof PyDict) return Array.from(iterable.keys());
-  if (iterable instanceof Set) return Array.from(iterable.values());
-  if (Array.isArray(iterable)) return iterable;
-  if (iterable && typeof iterable[Symbol.iterator] === 'function') return Array.from(iterable);
-  throw new Error('Object is not iterable');
-}
-
-export function matchValueEquals(left: any, right: any): boolean {
-  if (Array.isArray(left) && Array.isArray(right)) {
-    if (left.length !== right.length) return false;
-    for (let i = 0; i < left.length; i++) {
-      if (!matchValueEquals(left[i], right[i])) return false;
-    }
-    return true;
-  }
-  if (left instanceof Map && right instanceof Map) {
-    if (left.size !== right.size) return false;
-    for (const [k, v] of left.entries()) {
-      if (!right.has(k) || !matchValueEquals(v, right.get(k))) return false;
-    }
-    return true;
-  }
-  return left === right;
-}
-
-export function matchPattern(this: VirtualMachine, node: any, value: any, scope: Scope): { matched: boolean; bindings: Map<string, any> } {
-  switch (node.type) {
-    case ASTNodeType.MATCH_PATTERN_VALUE:
-      return { matched: matchValueEquals(value, this.evaluateExpression(node.value, scope)), bindings: new Map() };
-    case ASTNodeType.MATCH_PATTERN_WILDCARD:
-      return { matched: true, bindings: new Map() };
-    case ASTNodeType.MATCH_PATTERN_CAPTURE:
-      return { matched: true, bindings: new Map([[node.name, value]]) };
-    case ASTNodeType.MATCH_PATTERN_OR: {
-      for (const pattern of node.patterns || []) {
-        const result = this.matchPattern(pattern, value, scope);
-        if (result.matched) return result;
-      }
-      return { matched: false, bindings: new Map() };
-    }
-    case ASTNodeType.MATCH_PATTERN_SEQUENCE: {
-      const elements = node.elements || node.patterns;
-      if (!Array.isArray(value) || !elements || elements.length !== value.length) {
-        return { matched: false, bindings: new Map() };
-      }
-      const bindings = new Map<string, any>();
-      for (let i = 0; i < elements.length; i++) {
-        const result = this.matchPattern(elements[i], value[i], scope);
-        if (!result.matched) return { matched: false, bindings: new Map() };
-        for (const [k, v] of result.bindings.entries()) bindings.set(k, v);
-      }
-      return { matched: true, bindings };
-    }
-    case 'MatchValue':
-      return { matched: matchValueEquals(value, node.value), bindings: new Map() };
-    case 'MatchSingleton':
-      return { matched: value === node.value, bindings: new Map() };
-    case 'MatchSequence': {
-      if (!Array.isArray(value)) return { matched: false, bindings: new Map() };
-      if (!node.patterns || node.patterns.length !== value.length) return { matched: false, bindings: new Map() };
-      const bindings = new Map<string, any>();
-      for (let i = 0; i < node.patterns.length; i++) {
-        const result = this.matchPattern(node.patterns[i], value[i], scope);
-        if (!result.matched) return { matched: false, bindings: new Map() };
-        for (const [k, v] of result.bindings.entries()) bindings.set(k, v);
-      }
-      return { matched: true, bindings };
-    }
-    case 'MatchMapping': {
-      if (!(value instanceof PyDict)) return { matched: false, bindings: new Map() };
-      const bindings = new Map<string, any>();
-      for (const { key, pattern } of node.keys) {
-        if (!value.has(key)) return { matched: false, bindings: new Map() };
-        const result = this.matchPattern(pattern, value.get(key), scope);
-        if (!result.matched) return { matched: false, bindings: new Map() };
-        for (const [k, v] of result.bindings.entries()) bindings.set(k, v);
-      }
-      return { matched: true, bindings };
-    }
-    case 'MatchAs':
-      return {
-        matched: true,
-        bindings: node.name ? new Map([[node.name, value]]) : new Map(),
-      };
-    case 'MatchClass': {
-      if (!value || !value.klass || value.klass.name !== node.className) return { matched: false, bindings: new Map() };
-      const bindings = new Map<string, any>();
-      for (let i = 0; i < node.patterns.length; i++) {
-        const attrName = node.kwd_attrs[i] || node.patterns[i].name;
-        const attrValue = value.attributes.get(attrName);
-        const result = this.matchPattern(node.patterns[i], attrValue, scope);
-        if (!result.matched) return { matched: false, bindings: new Map() };
-        for (const [k, v] of result.bindings.entries()) bindings.set(k, v);
-      }
-      return { matched: true, bindings };
-    }
-    default:
-      return { matched: false, bindings: new Map() };
-  }
-}
-
-export function applyBindings(bindings: Map<string, any>, scope: Scope): void {
-  for (const [name, value] of bindings.entries()) {
-    scope.set(name, value);
-  }
-}
-
-export function* executeBlockGenerator(this: VirtualMachine, body: any[], scope: Scope): Generator<any, any, any> {
-  for (const stmt of body) {
-    yield* this.executeStatementGenerator(stmt, scope);
-  }
-  return null;
-}
-
-export function* executeStatementGenerator(this: VirtualMachine, node: any, scope: Scope): Generator<any, any, any> {
-  switch (node.type) {
-    case ASTNodeType.EXPRESSION_STATEMENT: {
-      if (this.expressionHasYield(node.expression)) {
-        yield* this.evaluateExpressionGenerator(node.expression, scope);
-        return null;
-      }
-      this.evaluateExpression(node.expression, scope);
-      return null;
-    }
-    case ASTNodeType.ASSIGNMENT: {
-      const value = this.expressionHasYield(node.value)
-        ? yield* this.evaluateExpressionGenerator(node.value, scope)
-        : this.evaluateExpression(node.value, scope);
-      for (const target of node.targets) {
-        this.assignTarget(target, value, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.IF_STATEMENT: {
-      const test = this.expressionHasYield(node.test)
-        ? yield* this.evaluateExpressionGenerator(node.test, scope)
-        : this.evaluateExpression(node.test, scope);
-      if (this.isTruthy(test, scope)) {
-        yield* this.executeBlockGenerator(node.body, scope);
-        return null;
-      }
-      for (const branch of node.elifs) {
-        const branchTest = this.expressionHasYield(branch.test)
-          ? yield* this.evaluateExpressionGenerator(branch.test, scope)
-          : this.evaluateExpression(branch.test, scope);
-        if (this.isTruthy(branchTest, scope)) {
-          yield* this.executeBlockGenerator(branch.body, scope);
-          return null;
-        }
-      }
-      if (node.orelse?.length) {
-        yield* this.executeBlockGenerator(node.orelse, scope);
-      }
-      return null;
-    }
-    case ASTNodeType.WHILE_STATEMENT: {
-      while (true) {
-        const test = this.expressionHasYield(node.test)
-          ? yield* this.evaluateExpressionGenerator(node.test, scope)
-          : this.evaluateExpression(node.test, scope);
-        if (!this.isTruthy(test, scope)) break;
-        try {
-          yield* this.executeBlockGenerator(node.body, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal) break;
-          if (err instanceof ContinueSignal) continue;
-          throw err;
-        }
-      }
-      return null;
-    }
-    case ASTNodeType.FOR_STATEMENT: {
-      const iterable = this.expressionHasYield(node.iter)
-        ? yield* this.evaluateExpressionGenerator(node.iter, scope)
-        : this.evaluateExpression(node.iter, scope);
-      const items = this.iterableToArray(iterable);
-      for (const item of items) {
-        this.assignTarget(node.target, item, scope);
-        try {
-          yield* this.executeBlockGenerator(node.body, scope);
-        } catch (err) {
-          if (err instanceof BreakSignal) break;
-          if (err instanceof ContinueSignal) continue;
-          throw err;
-        }
-      }
-      return null;
-    }
-    case ASTNodeType.MATCH_STATEMENT: {
-      const subject = this.expressionHasYield(node.subject)
-        ? yield* this.evaluateExpressionGenerator(node.subject, scope)
-        : this.evaluateExpression(node.subject, scope);
-      for (const matchCase of node.cases) {
-        const result = this.matchPattern(matchCase.pattern, subject, scope);
-        if (!result.matched) continue;
-        if (matchCase.guard) {
-          const guardScope = new Scope(scope);
-          this.applyBindings(result.bindings, guardScope);
-          const guardValue = this.expressionHasYield(matchCase.guard)
-            ? yield* this.evaluateExpressionGenerator(matchCase.guard, guardScope)
-            : this.evaluateExpression(matchCase.guard, guardScope);
-          if (!this.isTruthy(guardValue, scope)) continue;
-        }
-        this.applyBindings(result.bindings, scope);
-        yield* this.executeBlockGenerator(matchCase.body, scope);
-        return null;
-      }
-      return null;
-    }
-    case ASTNodeType.RETURN_STATEMENT: {
-      const value = node.value
-        ? (this.expressionHasYield(node.value)
-            ? yield* this.evaluateExpressionGenerator(node.value, scope)
-            : this.evaluateExpression(node.value, scope))
-        : null;
-      throw new ReturnSignal(value);
-    }
-    case ASTNodeType.BREAK_STATEMENT:
-      throw new BreakSignal();
-    case ASTNodeType.CONTINUE_STATEMENT:
-      throw new ContinueSignal();
-    case ASTNodeType.PASS_STATEMENT:
-      return null;
-    default:
-      return this.executeStatement(node, scope);
-  }
-}