path: root/src/interpreter/interpreter.ts

import {
  type ContinuationExpression,
  type PrimitiveOperationExpression,
  type ApplicationExpression,
  type RecordExpression,
  type Program,
  type Value,
  type RecordExpressionTuple,
  type SelectExpression,
} from '@/parser';
import { Environment, type Denotable, type DenotableRecord } from '.';
import {
  BadArgumentError,
  InvalidStateError,
  InvalidType,
  NotImplementedError,
  type TracingLogger,
} from '@/utils';
import { putBuiltinsOnEnvironemtn } from './builtins';

const evaluateValue = (
  value: Value,
  env: Environment,
  _logger: TracingLogger,
): Denotable => {
  if (typeof value === 'string') {
    return { type: 'string', value };
  }

  if ('real' in value) {
    return { type: 'real', value: value.real };
  }
  if ('int' in value) {
    return { type: 'int', value: value.int };
  }

  if ('bool' in value) {
    return { type: 'bool', value: value.bool };
  }

  if ('name' in value) {
    return env.get(value.name);
  }

  throw new InvalidStateError(`Invalid value: ${value}`);
};

const evaluateApplicationExpression = (
  { application }: ApplicationExpression,
  env: Environment,
  logger: TracingLogger,
): Denotable => {
  const { fn, args } = application;
  const argValues = args.map(arg =>
    evaluateValue(arg, env, logger.createChild('evaluateValue')),
  );
  return env.apply(fn.name, argValues);
};

const evaluatePrimitiveOperation = (
  { primitiveOperation }: PrimitiveOperationExpression,
  env: Environment,
  logger: TracingLogger,
) => {
  const { opr, operands, resultBindings, continuations } = primitiveOperation;
  const operandValues = operands.map(operand =>
    evaluateValue(operand, env, logger.createChild('evaluteValue')),
  );

  const result = env.apply(opr, operandValues);
  const continuationEnvironment = env.createChild();
  for (const { name } of resultBindings) {
    continuationEnvironment.set(name, result);
  }

  if (result.type === 'bool') {
    if (continuations.length > 2) {
      throw new BadArgumentError(
        `Expected <= 2 continuations for boolean result, got ${continuations.length}`,
      );
    }
    if (continuations.length !== 2) {
      logger.warn(
        `Expected 2 continuations for boolean result, got ContinuationLength=(${continuations.length})`,
      );
      return result;
    }

    const [trueContinuation, falseContinuation] = continuations;
    const childLogger = logger.createChild('continuation[true]');
    const continuation = result.value ? trueContinuation : falseContinuation;
    return evaluteContinuationExpression(
      continuation,
      continuationEnvironment,
      childLogger,
    );
  }

  if (continuations.length > 1) {
    throw new BadArgumentError(
      `Expected <= 1 continuations for non-boolean result, got ${continuations.length}`,
    );
  } else if (continuations.length === 0) {
    logger.warn(
      "Expected 1 continuation for non-boolean result, but there wasn't any. Implicitly returning the result", // technically undefined behavior
    );
    return result;
  }

  const [continuation] = continuations;
  const childLogger = logger.createChild('continuation');
  return evaluteContinuationExpression(
    continuation,
    continuationEnvironment,
    childLogger,
  );
};

export const evaluateRecordTuple = (
  tuple: RecordExpressionTuple,
  env: Environment,
  logger: TracingLogger,
): Denotable => {
  const { value, accessPath } = tuple;
  const record = evaluateValue(value, env, logger.createChild('evaluateValue'));
  if (record.type === 'record') {
    // TODO: Implement nested records at accessPath
    logger.debug(JSON.stringify(accessPath, null, 2));
    throw new NotImplementedError('Nested records are not yet supported');
  }

  return record;
};

export const evaluateRecordExpression = (
  { record }: RecordExpression,
  env: Environment,
  logger: TracingLogger,
): Denotable => {
  const {
    records,
    address: { name: address },
    body,
  } = record;

  const childEnv = env.createChild();
  const recordTuple = records.map(record =>
    evaluateRecordTuple(
      record,
      childEnv,
      logger.createChild('evaluateRecordTuple'),
    ),
  );
  const length = recordTuple.length;

  childEnv.set(address, {
    type: 'record',
    value: { length, record: recordTuple },
  });

  return evaluteContinuationExpression(
    body,
    childEnv,
    logger.createChild('evaluteContinuationExpression'),
  );
};

export const evaluateSelectExpression = (
  { select }: SelectExpression,
  env: Environment,
  logger: TracingLogger,
): Denotable => {
  const {
    index: { int: index },
    record,
    bind,
    continuation,
  } = select;
  const childEnv = env.createChild();

  const recordValue = evaluateValue(
    record,
    env,
    logger.createChild('evaluateValue'),
  );
  if (recordValue.type !== 'record') {
    throw new InvalidType('Expected record type');
  }

  const { value } = recordValue as { value: DenotableRecord };

  const selected = value.record[index];
  childEnv.set(bind.name, selected);

  return evaluteContinuationExpression(
    continuation,
    childEnv,
    logger.createChild('evaluteContinuationExpression'),
  );
};

const evaluteContinuationExpression = (
  expr: ContinuationExpression,
  env: Environment,
  logger: TracingLogger,
): Denotable => {
  if ('primitiveOperation' in expr) {
    logger.debug('Evaluating primitive operation');
    return evaluatePrimitiveOperation(
      expr,
      env,
      logger.createChild('evaluatePrimitiveOperation'),
    );
  }

  if ('application' in expr) {
    logger.debug('Evaluating function application');
    return evaluateApplicationExpression(
      expr,
      env,
      logger.createChild('evaluateApplicationExpression'),
    );
  }

  if ('record' in expr) {
    logger.debug('Evaluating record');
    return evaluateRecordExpression(
      expr,
      env,
      logger.createChild('evaluateRecordExpression'),
    );
  }
  if ('select' in expr) {
    logger.debug('Evaluating select');
    return evaluateSelectExpression(
      expr,
      env,
      logger.createChild('evaluateSelectExpression'),
    );
  }
  if ('offset' in expr) {
    throw new NotImplementedError('Continuation offset is not supported yet');
  }
  if ('switch' in expr) {
    throw new NotImplementedError('Continuation switch is not supported yet');
  }
  if ('fix' in expr) {
    throw new NotImplementedError('Continuation fix is not supported yet');
  }

  throw new InvalidStateError(`Invalid continuation expression: ${expr}`);
};

export const evaluate = async (
  ast: Program,
  logger: TracingLogger,
): Promise<Denotable> => {
  const globalEnvironment = putBuiltinsOnEnvironemtn(
    new Environment(logger.createChild('RootEnv')),
  );

  return ast.reduce((_, continuation, i) => {
    const exprLogger = logger.createChild(`statement[${i}]`);
    return evaluteContinuationExpression(
      continuation as ContinuationExpression,
      globalEnvironment,
      exprLogger,
    );
  }, null);
};