@glimmer/runtime/dist/commonjs/es2017/lib/vm/append.js

Minimal runtime needed to render Glimmer templates

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _env = require("@glimmer/env");

var _globalContext = require("@glimmer/global-context");

var _reference = require("@glimmer/reference");

var _util = require("@glimmer/util");

var _validator = require("@glimmer/validator");

var _vm = require("@glimmer/vm");

var _destroyable = require("@glimmer/destroyable");

var _vm2 = require("../compiled/opcodes/vm");

var _opcodes = require("../opcodes");

var _scope = require("../scope");

var _symbols = require("../symbols");

var _arguments = require("./arguments");

var _lowLevel = _interopRequireDefault(require("./low-level"));

var _renderResult = _interopRequireDefault(require("./render-result"));

var _stack = _interopRequireDefault(require("./stack"));

var _update = require("./update");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _a, _b;

class Stacks {
  constructor() {
    this.scope = new _util.Stack();
    this.dynamicScope = new _util.Stack();
    this.updating = new _util.Stack();
    this.cache = new _util.Stack();
    this.list = new _util.Stack();
  }

}

class VM {
  /**
   * End of migrated.
   */
  constructor(runtime, {
    pc,
    scope,
    dynamicScope,
    stack
  }, elementStack, context) {
    this.runtime = runtime;
    this.elementStack = elementStack;
    this.context = context;
    this[_a] = new Stacks();
    this[_b] = new _util.Stack();
    this.s0 = null;
    this.s1 = null;
    this.t0 = null;
    this.t1 = null;
    this.v0 = null;
    this.resume = initVM(this.context);

    if (_env.DEBUG) {
      (0, _globalContext.assertGlobalContextWasSet)();
    }

    let evalStack = _stack.default.restore(stack);

    false && (0, _util.assert)(typeof pc === 'number', 'pc is a number');
    evalStack[_symbols.REGISTERS][_vm.$pc] = pc;
    evalStack[_symbols.REGISTERS][_vm.$sp] = stack.length - 1;
    evalStack[_symbols.REGISTERS][_vm.$fp] = -1;
    this[_symbols.HEAP] = this.program.heap;
    this[_symbols.CONSTANTS] = this.program.constants;
    this.elementStack = elementStack;

    this[_symbols.STACKS].scope.push(scope);

    this[_symbols.STACKS].dynamicScope.push(dynamicScope);

    this[_symbols.ARGS] = new _arguments.VMArgumentsImpl();
    this[_symbols.INNER_VM] = new _lowLevel.default(evalStack, this[_symbols.HEAP], runtime.program, {
      debugBefore: opcode => {
        return _opcodes.APPEND_OPCODES.debugBefore(this, opcode);
      },
      debugAfter: state => {
        _opcodes.APPEND_OPCODES.debugAfter(this, state);
      }
    }, evalStack[_symbols.REGISTERS]);
    this.destructor = {};

    this[_symbols.DESTROYABLE_STACK].push(this.destructor);
  }

  get stack() {
    return this[_symbols.INNER_VM].stack;
  }
  /* Registers */


  get pc() {
    return this[_symbols.INNER_VM].fetchRegister(_vm.$pc);
  } // Fetch a value from a register onto the stack


  fetch(register) {
    let value = this.fetchValue(register);
    this.stack.push(value);
  } // Load a value from the stack into a register


  load(register) {
    let value = this.stack.pop();
    this.loadValue(register, value);
  }

  fetchValue(register) {
    if ((0, _vm.isLowLevelRegister)(register)) {
      return this[_symbols.INNER_VM].fetchRegister(register);
    }

    switch (register) {
      case _vm.$s0:
        return this.s0;

      case _vm.$s1:
        return this.s1;

      case _vm.$t0:
        return this.t0;

      case _vm.$t1:
        return this.t1;

      case _vm.$v0:
        return this.v0;
    }
  } // Load a value into a register


  loadValue(register, value) {
    if ((0, _vm.isLowLevelRegister)(register)) {
      this[_symbols.INNER_VM].loadRegister(register, value);
    }

    switch (register) {
      case _vm.$s0:
        this.s0 = value;
        break;

      case _vm.$s1:
        this.s1 = value;
        break;

      case _vm.$t0:
        this.t0 = value;
        break;

      case _vm.$t1:
        this.t1 = value;
        break;

      case _vm.$v0:
        this.v0 = value;
        break;
    }
  }
  /**
   * Migrated to Inner
   */
  // Start a new frame and save $ra and $fp on the stack


  pushFrame() {
    this[_symbols.INNER_VM].pushFrame();
  } // Restore $ra, $sp and $fp


  popFrame() {
    this[_symbols.INNER_VM].popFrame();
  } // Jump to an address in `program`


  goto(offset) {
    this[_symbols.INNER_VM].goto(offset);
  } // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)


  call(handle) {
    this[_symbols.INNER_VM].call(handle);
  } // Put a specific `program` address in $ra


  returnTo(offset) {
    this[_symbols.INNER_VM].returnTo(offset);
  } // Return to the `program` address stored in $ra


  return() {
    this[_symbols.INNER_VM].return();
  }

  static initial(runtime, context, {
    handle,
    self,
    dynamicScope,
    treeBuilder,
    numSymbols,
    owner
  }) {
    let scope = _scope.PartialScopeImpl.root(self, numSymbols, owner);

    let state = vmState(runtime.program.heap.getaddr(handle), scope, dynamicScope);
    let vm = initVM(context)(runtime, state, treeBuilder);
    vm.pushUpdating();
    return vm;
  }

  static empty(runtime, {
    handle,
    treeBuilder,
    dynamicScope,
    owner
  }, context) {
    let vm = initVM(context)(runtime, vmState(runtime.program.heap.getaddr(handle), _scope.PartialScopeImpl.root(_reference.UNDEFINED_REFERENCE, 0, owner), dynamicScope), treeBuilder);
    vm.pushUpdating();
    return vm;
  }

  compile(block) {
    let handle = (0, _util.unwrapHandle)(block.compile(this.context));
    return handle;
  }

  get program() {
    return this.runtime.program;
  }

  get env() {
    return this.runtime.env;
  }

  captureState(args, pc = this[_symbols.INNER_VM].fetchRegister(_vm.$pc)) {
    return {
      pc,
      scope: this.scope(),
      dynamicScope: this.dynamicScope(),
      stack: this.stack.capture(args)
    };
  }

  capture(args, pc = this[_symbols.INNER_VM].fetchRegister(_vm.$pc)) {
    return new _update.ResumableVMStateImpl(this.captureState(args, pc), this.resume);
  }

  beginCacheGroup(name) {
    let opcodes = this.updating();
    let guard = new _vm2.JumpIfNotModifiedOpcode();
    opcodes.push(guard);
    opcodes.push(new _vm2.BeginTrackFrameOpcode(name));

    this[_symbols.STACKS].cache.push(guard);

    (0, _validator.beginTrackFrame)(name);
  }

  commitCacheGroup() {
    let opcodes = this.updating();

    let guard = this[_symbols.STACKS].cache.pop();

    let tag = (0, _validator.endTrackFrame)();
    opcodes.push(new _vm2.EndTrackFrameOpcode(guard));
    guard.finalize(tag, opcodes.length);
  }

  enter(args) {
    let updating = [];
    let state = this.capture(args);
    let block = this.elements().pushUpdatableBlock();
    let tryOpcode = new _update.TryOpcode(state, this.runtime, block, updating);
    this.didEnter(tryOpcode);
  }

  enterItem({
    key,
    value,
    memo
  }) {
    let {
      stack
    } = this;
    let valueRef = (0, _reference.createIteratorItemRef)(value);
    let memoRef = (0, _reference.createIteratorItemRef)(memo);
    stack.push(valueRef);
    stack.push(memoRef);
    let state = this.capture(2);
    let block = this.elements().pushUpdatableBlock();
    let opcode = new _update.ListItemOpcode(state, this.runtime, block, key, memoRef, valueRef);
    this.didEnter(opcode);
    return opcode;
  }

  registerItem(opcode) {
    this.listBlock().initializeChild(opcode);
  }

  enterList(iterableRef, offset) {
    let updating = [];

    let addr = this[_symbols.INNER_VM].target(offset);

    let state = this.capture(0, addr);
    let list = this.elements().pushBlockList(updating);
    let opcode = new _update.ListBlockOpcode(state, this.runtime, list, updating, iterableRef);

    this[_symbols.STACKS].list.push(opcode);

    this.didEnter(opcode);
  }

  didEnter(opcode) {
    this.associateDestroyable(opcode);

    this[_symbols.DESTROYABLE_STACK].push(opcode);

    this.updateWith(opcode);
    this.pushUpdating(opcode.children);
  }

  exit() {
    this[_symbols.DESTROYABLE_STACK].pop();

    this.elements().popBlock();
    this.popUpdating();
  }

  exitList() {
    this.exit();

    this[_symbols.STACKS].list.pop();
  }

  pushUpdating(list = []) {
    this[_symbols.STACKS].updating.push(list);
  }

  popUpdating() {
    return this[_symbols.STACKS].updating.pop();
  }

  updateWith(opcode) {
    this.updating().push(opcode);
  }

  listBlock() {
    return this[_symbols.STACKS].list.current;
  }

  associateDestroyable(child) {
    let parent = this[_symbols.DESTROYABLE_STACK].current;
    (0, _destroyable.associateDestroyableChild)(parent, child);
  }

  tryUpdating() {
    return this[_symbols.STACKS].updating.current;
  }

  updating() {
    return this[_symbols.STACKS].updating.current;
  }

  elements() {
    return this.elementStack;
  }

  scope() {
    return this[_symbols.STACKS].scope.current;
  }

  dynamicScope() {
    return this[_symbols.STACKS].dynamicScope.current;
  }

  pushChildScope() {
    this[_symbols.STACKS].scope.push(this.scope().child());
  }

  pushDynamicScope() {
    let child = this.dynamicScope().child();

    this[_symbols.STACKS].dynamicScope.push(child);

    return child;
  }

  pushRootScope(size, owner) {
    let scope = _scope.PartialScopeImpl.sized(size, owner);

    this[_symbols.STACKS].scope.push(scope);

    return scope;
  }

  pushScope(scope) {
    this[_symbols.STACKS].scope.push(scope);
  }

  popScope() {
    this[_symbols.STACKS].scope.pop();
  }

  popDynamicScope() {
    this[_symbols.STACKS].dynamicScope.pop();
  } /// SCOPE HELPERS


  getOwner() {
    return this.scope().owner;
  }

  getSelf() {
    return this.scope().getSelf();
  }

  referenceForSymbol(symbol) {
    return this.scope().getSymbol(symbol);
  } /// EXECUTION


  execute(initialize) {
    if (_env.DEBUG) {
      let hasErrored = true;

      try {
        let value = this._execute(initialize); // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions"
        // which would happen with a `catch` + `throw`


        hasErrored = false;
        return value;
      } finally {
        if (hasErrored) {
          // If any existing blocks are open, due to an error or something like
          // that, we need to close them all and clean things up properly.
          let elements = this.elements();

          while (elements.hasBlocks) {
            elements.popBlock();
          } // eslint-disable-next-line no-console


          console.error(`\n\nError occurred:\n\n${(0, _validator.resetTracking)()}\n\n`);
        }
      }
    } else {
      return this._execute(initialize);
    }
  }

  _execute(initialize) {
    if (false
    /* LOCAL_SHOULD_LOG */
    ) {
        _util.LOCAL_LOGGER.log(`EXECUTING FROM ${this[_symbols.INNER_VM].fetchRegister(_vm.$pc)}`);
      }

    if (initialize) initialize(this);
    let result;

    while (true) {
      result = this.next();
      if (result.done) break;
    }

    return result.value;
  }

  next() {
    let {
      env,
      elementStack
    } = this;

    let opcode = this[_symbols.INNER_VM].nextStatement();

    let result;

    if (opcode !== null) {
      this[_symbols.INNER_VM].evaluateOuter(opcode, this);

      result = {
        done: false,
        value: null
      };
    } else {
      // Unload the stack
      this.stack.reset();
      result = {
        done: true,
        value: new _renderResult.default(env, this.popUpdating(), elementStack.popBlock(), this.destructor)
      };
    }

    return result;
  }

  bindDynamicScope(names) {
    let scope = this.dynamicScope();

    for (let i = names.length - 1; i >= 0; i--) {
      let name = names[i];
      scope.set(name, this.stack.pop());
    }
  }

}

exports.default = VM;
_a = _symbols.STACKS, _b = _symbols.DESTROYABLE_STACK;

function vmState(pc, scope, dynamicScope) {
  return {
    pc,
    scope,
    dynamicScope,
    stack: []
  };
}

function initVM(context) {
  return (runtime, state, builder) => new VM(runtime, state, builder, context);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/runtime/lib/vm/append.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEBUG } from '@glimmer/env';\nimport { assertGlobalContextWasSet } from '@glimmer/global-context';\nimport {\n  CompilableTemplate,\n  Destroyable,\n  DynamicScope,\n  ElementBuilder,\n  Environment,\n  Option,\n  PartialScope,\n  RenderResult,\n  RichIteratorResult,\n  RuntimeConstants,\n  RuntimeContext,\n  RuntimeHeap,\n  RuntimeProgram,\n  Scope,\n  CompileTimeCompilationContext,\n  VM as PublicVM,\n  ResolutionTimeConstants,\n  Owner,\n  UpdatingOpcode,\n} from '@glimmer/interfaces';\nimport { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';\nimport { RuntimeOpImpl } from '@glimmer/program';\nimport {\n  createIteratorItemRef,\n  OpaqueIterationItem,\n  OpaqueIterator,\n  Reference,\n  UNDEFINED_REFERENCE,\n} from '@glimmer/reference';\nimport { assert, expect, LOCAL_LOGGER, Stack, unwrapHandle } from '@glimmer/util';\nimport { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator';\nimport {\n  $fp,\n  $pc,\n  $s0,\n  $s1,\n  $sp,\n  $t0,\n  $t1,\n  $v0,\n  isLowLevelRegister,\n  MachineRegister,\n  Register,\n  SyscallRegister,\n} from '@glimmer/vm';\nimport { associateDestroyableChild } from '@glimmer/destroyable';\nimport {\n  BeginTrackFrameOpcode,\n  EndTrackFrameOpcode,\n  JumpIfNotModifiedOpcode,\n} from '../compiled/opcodes/vm';\nimport { APPEND_OPCODES, DebugState } from '../opcodes';\nimport { PartialScopeImpl } from '../scope';\nimport { ARGS, CONSTANTS, DESTROYABLE_STACK, HEAP, INNER_VM, REGISTERS, STACKS } from '../symbols';\nimport { VMArgumentsImpl } from './arguments';\nimport { LiveBlockList } from './element-builder';\nimport LowLevelVM from './low-level';\nimport RenderResultImpl from './render-result';\nimport EvaluationStackImpl, { EvaluationStack } from './stack';\nimport {\n  BlockOpcode,\n  ListBlockOpcode,\n  ListItemOpcode,\n  ResumableVMState,\n  ResumableVMStateImpl,\n  TryOpcode,\n  VMState,\n} from './update';\n\n/**\n * This interface is used by internal opcodes, and is more stable than\n * the implementation of the Append VM itself.\n */\nexport interface InternalVM {\n  readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;\n  readonly [ARGS]: VMArgumentsImpl;\n\n  readonly env: Environment;\n  readonly stack: EvaluationStack;\n  readonly runtime: RuntimeContext;\n  readonly context: CompileTimeCompilationContext;\n\n  loadValue(register: MachineRegister, value: number): void;\n  loadValue(register: Register, value: unknown): void;\n  loadValue(register: Register | MachineRegister, value: unknown): void;\n\n  fetchValue(register: MachineRegister.ra | MachineRegister.pc): number;\n  // TODO: Something better than a type assertion?\n  fetchValue<T>(register: Register): T;\n  fetchValue(register: Register): unknown;\n\n  load(register: Register): void;\n  fetch(register: Register): void;\n\n  compile(block: CompilableTemplate): number;\n\n  scope(): Scope;\n  elements(): ElementBuilder;\n\n  getOwner(): Owner;\n  getSelf(): Reference;\n\n  updateWith(opcode: UpdatingOpcode): void;\n\n  associateDestroyable(d: Destroyable): void;\n\n  beginCacheGroup(name?: string): void;\n  commitCacheGroup(): void;\n\n  /// Iteration ///\n\n  enterList(iterableRef: Reference<OpaqueIterator>, offset: number): void;\n  exitList(): void;\n  enterItem(item: OpaqueIterationItem): ListItemOpcode;\n  registerItem(item: ListItemOpcode): void;\n\n  pushRootScope(size: number, owner: Owner): PartialScope;\n  pushChildScope(): void;\n  popScope(): void;\n  pushScope(scope: Scope): void;\n\n  dynamicScope(): DynamicScope;\n  bindDynamicScope(names: string[]): void;\n  pushDynamicScope(): void;\n  popDynamicScope(): void;\n\n  enter(args: number): void;\n  exit(): void;\n\n  goto(pc: number): void;\n  call(handle: number): void;\n  pushFrame(): void;\n\n  referenceForSymbol(symbol: number): Reference;\n\n  execute(initialize?: (vm: this) => void): RenderResult;\n  pushUpdating(list?: UpdatingOpcode[]): void;\n  next(): RichIteratorResult<null, RenderResult>;\n}\n\nclass Stacks {\n  readonly scope = new Stack<Scope>();\n  readonly dynamicScope = new Stack<DynamicScope>();\n  readonly updating = new Stack<UpdatingOpcode[]>();\n  readonly cache = new Stack<JumpIfNotModifiedOpcode>();\n  readonly list = new Stack<ListBlockOpcode>();\n}\n\nexport default class VM implements PublicVM, InternalVM {\n  private readonly [STACKS] = new Stacks();\n  private readonly [HEAP]: RuntimeHeap;\n  private readonly destructor: object;\n  private readonly [DESTROYABLE_STACK] = new Stack<object>();\n  readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;\n  readonly [ARGS]: VMArgumentsImpl;\n  readonly [INNER_VM]: LowLevelVM;\n\n  get stack(): EvaluationStack {\n    return this[INNER_VM].stack as EvaluationStack;\n  }\n\n  /* Registers */\n\n  get pc(): number {\n    return this[INNER_VM].fetchRegister($pc);\n  }\n\n  public s0: unknown = null;\n  public s1: unknown = null;\n  public t0: unknown = null;\n  public t1: unknown = null;\n  public v0: unknown = null;\n\n  // Fetch a value from a register onto the stack\n  fetch(register: SyscallRegister): void {\n    let value = this.fetchValue(register);\n\n    this.stack.push(value);\n  }\n\n  // Load a value from the stack into a register\n  load(register: SyscallRegister) {\n    let value = this.stack.pop();\n\n    this.loadValue(register, value);\n  }\n\n  // Fetch a value from a register\n  fetchValue(register: MachineRegister): number;\n  fetchValue<T>(register: Register): T;\n  fetchValue(register: Register | MachineRegister): unknown {\n    if (isLowLevelRegister(register)) {\n      return this[INNER_VM].fetchRegister(register);\n    }\n\n    switch (register) {\n      case $s0:\n        return this.s0;\n      case $s1:\n        return this.s1;\n      case $t0:\n        return this.t0;\n      case $t1:\n        return this.t1;\n      case $v0:\n        return this.v0;\n    }\n  }\n\n  // Load a value into a register\n\n  loadValue<T>(register: Register | MachineRegister, value: T): void {\n    if (isLowLevelRegister(register)) {\n      this[INNER_VM].loadRegister(register, (value as any) as number);\n    }\n\n    switch (register) {\n      case $s0:\n        this.s0 = value;\n        break;\n      case $s1:\n        this.s1 = value;\n        break;\n      case $t0:\n        this.t0 = value;\n        break;\n      case $t1:\n        this.t1 = value;\n        break;\n      case $v0:\n        this.v0 = value;\n        break;\n    }\n  }\n\n  /**\n   * Migrated to Inner\n   */\n\n  // Start a new frame and save $ra and $fp on the stack\n  pushFrame() {\n    this[INNER_VM].pushFrame();\n  }\n\n  // Restore $ra, $sp and $fp\n  popFrame() {\n    this[INNER_VM].popFrame();\n  }\n\n  // Jump to an address in `program`\n  goto(offset: number) {\n    this[INNER_VM].goto(offset);\n  }\n\n  // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)\n  call(handle: number) {\n    this[INNER_VM].call(handle);\n  }\n\n  // Put a specific `program` address in $ra\n  returnTo(offset: number) {\n    this[INNER_VM].returnTo(offset);\n  }\n\n  // Return to the `program` address stored in $ra\n  return() {\n    this[INNER_VM].return();\n  }\n\n  /**\n   * End of migrated.\n   */\n\n  constructor(\n    readonly runtime: RuntimeContext,\n    { pc, scope, dynamicScope, stack }: VMState,\n    private readonly elementStack: ElementBuilder,\n    readonly context: CompileTimeCompilationContext\n  ) {\n    if (DEBUG) {\n      assertGlobalContextWasSet!();\n    }\n\n    let evalStack = EvaluationStackImpl.restore(stack);\n\n    assert(typeof pc === 'number', 'pc is a number');\n\n    evalStack[REGISTERS][$pc] = pc;\n    evalStack[REGISTERS][$sp] = stack.length - 1;\n    evalStack[REGISTERS][$fp] = -1;\n\n    this[HEAP] = this.program.heap;\n    this[CONSTANTS] = this.program.constants;\n    this.elementStack = elementStack;\n    this[STACKS].scope.push(scope);\n    this[STACKS].dynamicScope.push(dynamicScope);\n    this[ARGS] = new VMArgumentsImpl();\n    this[INNER_VM] = new LowLevelVM(\n      evalStack,\n      this[HEAP],\n      runtime.program,\n      {\n        debugBefore: (opcode: RuntimeOpImpl): DebugState => {\n          return APPEND_OPCODES.debugBefore(this, opcode);\n        },\n\n        debugAfter: (state: DebugState): void => {\n          APPEND_OPCODES.debugAfter(this, state);\n        },\n      },\n      evalStack[REGISTERS]\n    );\n\n    this.destructor = {};\n    this[DESTROYABLE_STACK].push(this.destructor);\n  }\n\n  static initial(\n    runtime: RuntimeContext,\n    context: CompileTimeCompilationContext,\n    { handle, self, dynamicScope, treeBuilder, numSymbols, owner }: InitOptions\n  ) {\n    let scope = PartialScopeImpl.root(self, numSymbols, owner);\n    let state = vmState(runtime.program.heap.getaddr(handle), scope, dynamicScope);\n    let vm = initVM(context)(runtime, state, treeBuilder);\n    vm.pushUpdating();\n    return vm;\n  }\n\n  static empty(\n    runtime: RuntimeContext,\n    { handle, treeBuilder, dynamicScope, owner }: MinimalInitOptions,\n    context: CompileTimeCompilationContext\n  ) {\n    let vm = initVM(context)(\n      runtime,\n      vmState(\n        runtime.program.heap.getaddr(handle),\n        PartialScopeImpl.root(UNDEFINED_REFERENCE, 0, owner),\n        dynamicScope\n      ),\n      treeBuilder\n    );\n    vm.pushUpdating();\n    return vm;\n  }\n\n  private resume: VmInitCallback = initVM(this.context);\n\n  compile(block: CompilableTemplate): number {\n    let handle = unwrapHandle(block.compile(this.context));\n\n    return handle;\n  }\n\n  get program(): RuntimeProgram {\n    return this.runtime.program;\n  }\n\n  get env(): Environment {\n    return this.runtime.env;\n  }\n\n  captureState(args: number, pc = this[INNER_VM].fetchRegister($pc)): VMState {\n    return {\n      pc,\n      scope: this.scope(),\n      dynamicScope: this.dynamicScope(),\n      stack: this.stack.capture(args),\n    };\n  }\n\n  capture(args: number, pc = this[INNER_VM].fetchRegister($pc)): ResumableVMState {\n    return new ResumableVMStateImpl(this.captureState(args, pc), this.resume);\n  }\n\n  beginCacheGroup(name?: string) {\n    let opcodes = this.updating();\n    let guard = new JumpIfNotModifiedOpcode();\n\n    opcodes.push(guard);\n    opcodes.push(new BeginTrackFrameOpcode(name));\n    this[STACKS].cache.push(guard);\n\n    beginTrackFrame(name);\n  }\n\n  commitCacheGroup() {\n    let opcodes = this.updating();\n    let guard = expect(this[STACKS].cache.pop(), 'VM BUG: Expected a cache group');\n\n    let tag = endTrackFrame();\n    opcodes.push(new EndTrackFrameOpcode(guard));\n\n    guard.finalize(tag, opcodes.length);\n  }\n\n  enter(args: number) {\n    let updating: UpdatingOpcode[] = [];\n\n    let state = this.capture(args);\n    let block = this.elements().pushUpdatableBlock();\n\n    let tryOpcode = new TryOpcode(state, this.runtime, block, updating);\n\n    this.didEnter(tryOpcode);\n  }\n\n  enterItem({ key, value, memo }: OpaqueIterationItem): ListItemOpcode {\n    let { stack } = this;\n\n    let valueRef = createIteratorItemRef(value);\n    let memoRef = createIteratorItemRef(memo);\n\n    stack.push(valueRef);\n    stack.push(memoRef);\n\n    let state = this.capture(2);\n    let block = this.elements().pushUpdatableBlock();\n\n    let opcode = new ListItemOpcode(state, this.runtime, block, key, memoRef, valueRef);\n    this.didEnter(opcode);\n\n    return opcode;\n  }\n\n  registerItem(opcode: ListItemOpcode) {\n    this.listBlock().initializeChild(opcode);\n  }\n\n  enterList(iterableRef: Reference<OpaqueIterator>, offset: number) {\n    let updating: ListItemOpcode[] = [];\n\n    let addr = this[INNER_VM].target(offset);\n    let state = this.capture(0, addr);\n    let list = this.elements().pushBlockList(updating) as LiveBlockList;\n\n    let opcode = new ListBlockOpcode(state, this.runtime, list, updating, iterableRef);\n\n    this[STACKS].list.push(opcode);\n\n    this.didEnter(opcode);\n  }\n\n  private didEnter(opcode: BlockOpcode) {\n    this.associateDestroyable(opcode);\n    this[DESTROYABLE_STACK].push(opcode);\n    this.updateWith(opcode);\n    this.pushUpdating(opcode.children);\n  }\n\n  exit() {\n    this[DESTROYABLE_STACK].pop();\n    this.elements().popBlock();\n    this.popUpdating();\n  }\n\n  exitList() {\n    this.exit();\n    this[STACKS].list.pop();\n  }\n\n  pushUpdating(list: UpdatingOpcode[] = []): void {\n    this[STACKS].updating.push(list);\n  }\n\n  popUpdating(): UpdatingOpcode[] {\n    return expect(this[STACKS].updating.pop(), \"can't pop an empty stack\");\n  }\n\n  updateWith(opcode: UpdatingOpcode) {\n    this.updating().push(opcode);\n  }\n\n  listBlock(): ListBlockOpcode {\n    return expect(this[STACKS].list.current, 'expected a list block');\n  }\n\n  associateDestroyable(child: Destroyable): void {\n    let parent = expect(this[DESTROYABLE_STACK].current, 'Expected destructor parent');\n    associateDestroyableChild(parent, child);\n  }\n\n  tryUpdating(): Option<UpdatingOpcode[]> {\n    return this[STACKS].updating.current;\n  }\n\n  updating(): UpdatingOpcode[] {\n    return expect(\n      this[STACKS].updating.current,\n      'expected updating opcode on the updating opcode stack'\n    );\n  }\n\n  elements(): ElementBuilder {\n    return this.elementStack;\n  }\n\n  scope(): Scope {\n    return expect(this[STACKS].scope.current, 'expected scope on the scope stack');\n  }\n\n  dynamicScope(): DynamicScope {\n    return expect(\n      this[STACKS].dynamicScope.current,\n      'expected dynamic scope on the dynamic scope stack'\n    );\n  }\n\n  pushChildScope() {\n    this[STACKS].scope.push(this.scope().child());\n  }\n\n  pushDynamicScope(): DynamicScope {\n    let child = this.dynamicScope().child();\n    this[STACKS].dynamicScope.push(child);\n    return child;\n  }\n\n  pushRootScope(size: number, owner: Owner): PartialScope {\n    let scope = PartialScopeImpl.sized(size, owner);\n    this[STACKS].scope.push(scope);\n    return scope;\n  }\n\n  pushScope(scope: Scope) {\n    this[STACKS].scope.push(scope);\n  }\n\n  popScope() {\n    this[STACKS].scope.pop();\n  }\n\n  popDynamicScope() {\n    this[STACKS].dynamicScope.pop();\n  }\n\n  /// SCOPE HELPERS\n\n  getOwner(): Owner {\n    return this.scope().owner;\n  }\n\n  getSelf(): Reference<any> {\n    return this.scope().getSelf();\n  }\n\n  referenceForSymbol(symbol: number): Reference {\n    return this.scope().getSymbol(symbol);\n  }\n\n  /// EXECUTION\n\n  execute(initialize?: (vm: this) => void): RenderResult {\n    if (DEBUG) {\n      let hasErrored = true;\n      try {\n        let value = this._execute(initialize);\n\n        // using a boolean here to avoid breaking ergonomics of \"pause on uncaught exceptions\"\n        // which would happen with a `catch` + `throw`\n        hasErrored = false;\n\n        return value;\n      } finally {\n        if (hasErrored) {\n          // If any existing blocks are open, due to an error or something like\n          // that, we need to close them all and clean things up properly.\n          let elements = this.elements();\n\n          while (elements.hasBlocks) {\n            elements.popBlock();\n          }\n\n          // eslint-disable-next-line no-console\n          console.error(`\\n\\nError occurred:\\n\\n${resetTracking()}\\n\\n`);\n        }\n      }\n    } else {\n      return this._execute(initialize);\n    }\n  }\n\n  private _execute(initialize?: (vm: this) => void): RenderResult {\n    if (LOCAL_SHOULD_LOG) {\n      LOCAL_LOGGER.log(`EXECUTING FROM ${this[INNER_VM].fetchRegister($pc)}`);\n    }\n\n    if (initialize) initialize(this);\n\n    let result: RichIteratorResult<null, RenderResult>;\n\n    while (true) {\n      result = this.next();\n      if (result.done) break;\n    }\n\n    return result.value;\n  }\n\n  next(): RichIteratorResult<null, RenderResult> {\n    let { env, elementStack } = this;\n    let opcode = this[INNER_VM].nextStatement();\n    let result: RichIteratorResult<null, RenderResult>;\n    if (opcode !== null) {\n      this[INNER_VM].evaluateOuter(opcode, this);\n      result = { done: false, value: null };\n    } else {\n      // Unload the stack\n      this.stack.reset();\n\n      result = {\n        done: true,\n        value: new RenderResultImpl(\n          env,\n          this.popUpdating(),\n          elementStack.popBlock(),\n          this.destructor\n        ),\n      };\n    }\n    return result;\n  }\n\n  bindDynamicScope(names: string[]) {\n    let scope = this.dynamicScope();\n\n    for (let i = names.length - 1; i >= 0; i--) {\n      let name = names[i];\n      scope.set(name, this.stack.pop<Reference<unknown>>());\n    }\n  }\n}\n\nfunction vmState(pc: number, scope: Scope, dynamicScope: DynamicScope) {\n  return {\n    pc,\n    scope,\n    dynamicScope,\n    stack: [],\n  };\n}\n\nexport interface MinimalInitOptions {\n  handle: number;\n  treeBuilder: ElementBuilder;\n  dynamicScope: DynamicScope;\n  owner: Owner;\n}\n\nexport interface InitOptions extends MinimalInitOptions {\n  self: Reference;\n  numSymbols: number;\n}\n\nexport type VmInitCallback = (\n  this: void,\n  runtime: RuntimeContext,\n  state: VMState,\n  builder: ElementBuilder\n) => InternalVM;\n\nfunction initVM(context: CompileTimeCompilationContext): VmInitCallback {\n  return (runtime, state, builder) => new VM(runtime, state, builder, context);\n}\n"],"sourceRoot":""}