@glimmer/runtime/dist/modules/es5/lib/vm/append.js

Minimal runtime needed to render Glimmer templates

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

var _a, _b;

import { DEBUG } from '@glimmer/env';
import { assertGlobalContextWasSet } from '@glimmer/global-context';
import { createIteratorItemRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
import { assert, LOCAL_LOGGER, Stack, unwrapHandle } from '@glimmer/util';
import { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator';
import { $fp, $pc, $s0, $s1, $sp, $t0, $t1, $v0, isLowLevelRegister } from '@glimmer/vm';
import { associateDestroyableChild } from '@glimmer/destroyable';
import { BeginTrackFrameOpcode, EndTrackFrameOpcode, JumpIfNotModifiedOpcode } from '../compiled/opcodes/vm';
import { APPEND_OPCODES } from '../opcodes';
import { PartialScopeImpl } from '../scope';
import { ARGS, CONSTANTS, DESTROYABLE_STACK, HEAP, INNER_VM, REGISTERS, STACKS } from '../symbols';
import { VMArgumentsImpl } from './arguments';
import LowLevelVM from './low-level';
import RenderResultImpl from './render-result';
import EvaluationStackImpl from './stack';
import { ListBlockOpcode, ListItemOpcode, ResumableVMStateImpl, TryOpcode } from './update';

var Stacks = function Stacks() {
  this.scope = new Stack();
  this.dynamicScope = new Stack();
  this.updating = new Stack();
  this.cache = new Stack();
  this.list = new Stack();
};

var VM = /*#__PURE__*/function () {
  /**
   * End of migrated.
   */
  function VM(runtime, _ref, elementStack, context) {
    var _this = this;

    var pc = _ref.pc,
        scope = _ref.scope,
        dynamicScope = _ref.dynamicScope,
        stack = _ref.stack;
    this.runtime = runtime;
    this.elementStack = elementStack;
    this.context = context;
    this[_a] = new Stacks();
    this[_b] = new Stack();
    this.s0 = null;
    this.s1 = null;
    this.t0 = null;
    this.t1 = null;
    this.v0 = null;
    this.resume = initVM(this.context);

    if (DEBUG) {
      assertGlobalContextWasSet();
    }

    var evalStack = EvaluationStackImpl.restore(stack);
    false && assert(typeof pc === 'number', 'pc is a number');
    evalStack[REGISTERS][$pc] = pc;
    evalStack[REGISTERS][$sp] = stack.length - 1;
    evalStack[REGISTERS][$fp] = -1;
    this[HEAP] = this.program.heap;
    this[CONSTANTS] = this.program.constants;
    this.elementStack = elementStack;
    this[STACKS].scope.push(scope);
    this[STACKS].dynamicScope.push(dynamicScope);
    this[ARGS] = new VMArgumentsImpl();
    this[INNER_VM] = new LowLevelVM(evalStack, this[HEAP], runtime.program, {
      debugBefore: function debugBefore(opcode) {
        return APPEND_OPCODES.debugBefore(_this, opcode);
      },
      debugAfter: function debugAfter(state) {
        APPEND_OPCODES.debugAfter(_this, state);
      }
    }, evalStack[REGISTERS]);
    this.destructor = {};
    this[DESTROYABLE_STACK].push(this.destructor);
  }

  var _proto = VM.prototype;

  // Fetch a value from a register onto the stack
  _proto.fetch = function fetch(register) {
    var value = this.fetchValue(register);
    this.stack.push(value);
  } // Load a value from the stack into a register
  ;

  _proto.load = function load(register) {
    var value = this.stack.pop();
    this.loadValue(register, value);
  };

  _proto.fetchValue = function fetchValue(register) {
    if (isLowLevelRegister(register)) {
      return this[INNER_VM].fetchRegister(register);
    }

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

      case $s1:
        return this.s1;

      case $t0:
        return this.t0;

      case $t1:
        return this.t1;

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

  _proto.loadValue = function loadValue(register, value) {
    if (isLowLevelRegister(register)) {
      this[INNER_VM].loadRegister(register, value);
    }

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

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

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

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

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

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

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

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

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

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

  _proto["return"] = function _return() {
    this[INNER_VM]["return"]();
  };

  VM.initial = function initial(runtime, context, _ref2) {
    var handle = _ref2.handle,
        self = _ref2.self,
        dynamicScope = _ref2.dynamicScope,
        treeBuilder = _ref2.treeBuilder,
        numSymbols = _ref2.numSymbols,
        owner = _ref2.owner;
    var scope = PartialScopeImpl.root(self, numSymbols, owner);
    var state = vmState(runtime.program.heap.getaddr(handle), scope, dynamicScope);
    var vm = initVM(context)(runtime, state, treeBuilder);
    vm.pushUpdating();
    return vm;
  };

  VM.empty = function empty(runtime, _ref3, context) {
    var handle = _ref3.handle,
        treeBuilder = _ref3.treeBuilder,
        dynamicScope = _ref3.dynamicScope,
        owner = _ref3.owner;
    var vm = initVM(context)(runtime, vmState(runtime.program.heap.getaddr(handle), PartialScopeImpl.root(UNDEFINED_REFERENCE, 0, owner), dynamicScope), treeBuilder);
    vm.pushUpdating();
    return vm;
  };

  _proto.compile = function compile(block) {
    var handle = unwrapHandle(block.compile(this.context));
    return handle;
  };

  _proto.captureState = function captureState(args, pc) {
    if (pc === void 0) {
      pc = this[INNER_VM].fetchRegister($pc);
    }

    return {
      pc: pc,
      scope: this.scope(),
      dynamicScope: this.dynamicScope(),
      stack: this.stack.capture(args)
    };
  };

  _proto.capture = function capture(args, pc) {
    if (pc === void 0) {
      pc = this[INNER_VM].fetchRegister($pc);
    }

    return new ResumableVMStateImpl(this.captureState(args, pc), this.resume);
  };

  _proto.beginCacheGroup = function beginCacheGroup(name) {
    var opcodes = this.updating();
    var guard = new JumpIfNotModifiedOpcode();
    opcodes.push(guard);
    opcodes.push(new BeginTrackFrameOpcode(name));
    this[STACKS].cache.push(guard);
    beginTrackFrame(name);
  };

  _proto.commitCacheGroup = function commitCacheGroup() {
    var opcodes = this.updating();
    var guard = this[STACKS].cache.pop();
    var tag = endTrackFrame();
    opcodes.push(new EndTrackFrameOpcode(guard));
    guard.finalize(tag, opcodes.length);
  };

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

  _proto.enterItem = function enterItem(_ref4) {
    var key = _ref4.key,
        value = _ref4.value,
        memo = _ref4.memo;
    var stack = this.stack;
    var valueRef = createIteratorItemRef(value);
    var memoRef = createIteratorItemRef(memo);
    stack.push(valueRef);
    stack.push(memoRef);
    var state = this.capture(2);
    var block = this.elements().pushUpdatableBlock();
    var opcode = new ListItemOpcode(state, this.runtime, block, key, memoRef, valueRef);
    this.didEnter(opcode);
    return opcode;
  };

  _proto.registerItem = function registerItem(opcode) {
    this.listBlock().initializeChild(opcode);
  };

  _proto.enterList = function enterList(iterableRef, offset) {
    var updating = [];
    var addr = this[INNER_VM].target(offset);
    var state = this.capture(0, addr);
    var list = this.elements().pushBlockList(updating);
    var opcode = new ListBlockOpcode(state, this.runtime, list, updating, iterableRef);
    this[STACKS].list.push(opcode);
    this.didEnter(opcode);
  };

  _proto.didEnter = function didEnter(opcode) {
    this.associateDestroyable(opcode);
    this[DESTROYABLE_STACK].push(opcode);
    this.updateWith(opcode);
    this.pushUpdating(opcode.children);
  };

  _proto.exit = function exit() {
    this[DESTROYABLE_STACK].pop();
    this.elements().popBlock();
    this.popUpdating();
  };

  _proto.exitList = function exitList() {
    this.exit();
    this[STACKS].list.pop();
  };

  _proto.pushUpdating = function pushUpdating(list) {
    if (list === void 0) {
      list = [];
    }

    this[STACKS].updating.push(list);
  };

  _proto.popUpdating = function popUpdating() {
    return this[STACKS].updating.pop();
  };

  _proto.updateWith = function updateWith(opcode) {
    this.updating().push(opcode);
  };

  _proto.listBlock = function listBlock() {
    return this[STACKS].list.current;
  };

  _proto.associateDestroyable = function associateDestroyable(child) {
    var parent = this[DESTROYABLE_STACK].current;
    associateDestroyableChild(parent, child);
  };

  _proto.tryUpdating = function tryUpdating() {
    return this[STACKS].updating.current;
  };

  _proto.updating = function updating() {
    return this[STACKS].updating.current;
  };

  _proto.elements = function elements() {
    return this.elementStack;
  };

  _proto.scope = function scope() {
    return this[STACKS].scope.current;
  };

  _proto.dynamicScope = function dynamicScope() {
    return this[STACKS].dynamicScope.current;
  };

  _proto.pushChildScope = function pushChildScope() {
    this[STACKS].scope.push(this.scope().child());
  };

  _proto.pushDynamicScope = function pushDynamicScope() {
    var child = this.dynamicScope().child();
    this[STACKS].dynamicScope.push(child);
    return child;
  };

  _proto.pushRootScope = function pushRootScope(size, owner) {
    var scope = PartialScopeImpl.sized(size, owner);
    this[STACKS].scope.push(scope);
    return scope;
  };

  _proto.pushScope = function pushScope(scope) {
    this[STACKS].scope.push(scope);
  };

  _proto.popScope = function popScope() {
    this[STACKS].scope.pop();
  };

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

  _proto.getOwner = function getOwner() {
    return this.scope().owner;
  };

  _proto.getSelf = function getSelf() {
    return this.scope().getSelf();
  };

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

  _proto.execute = function execute(initialize) {
    if (DEBUG) {
      var hasErrored = true;

      try {
        var 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.
          var elements = this.elements();

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


          console.error("\n\nError occurred:\n\n" + resetTracking() + "\n\n");
        }
      }
    } else {
      return this._execute(initialize);
    }
  };

  _proto._execute = function _execute(initialize) {
    if (false
    /* LOCAL_SHOULD_LOG */
    ) {
        LOCAL_LOGGER.log("EXECUTING FROM " + this[INNER_VM].fetchRegister($pc));
      }

    if (initialize) initialize(this);
    var result;

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

    return result.value;
  };

  _proto.next = function next() {
    var env = this.env,
        elementStack = this.elementStack;
    var opcode = this[INNER_VM].nextStatement();
    var result;

    if (opcode !== null) {
      this[INNER_VM].evaluateOuter(opcode, this);
      result = {
        done: false,
        value: null
      };
    } else {
      // Unload the stack
      this.stack.reset();
      result = {
        done: true,
        value: new RenderResultImpl(env, this.popUpdating(), elementStack.popBlock(), this.destructor)
      };
    }

    return result;
  };

  _proto.bindDynamicScope = function bindDynamicScope(names) {
    var scope = this.dynamicScope();

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

  _createClass(VM, [{
    key: "stack",
    get: function get() {
      return this[INNER_VM].stack;
    }
    /* Registers */

  }, {
    key: "pc",
    get: function get() {
      return this[INNER_VM].fetchRegister($pc);
    }
  }, {
    key: "program",
    get: function get() {
      return this.runtime.program;
    }
  }, {
    key: "env",
    get: function get() {
      return this.runtime.env;
    }
  }]);

  return VM;
}();

export { VM as default };
_a = STACKS, _b = DESTROYABLE_STACK;

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

function initVM(context) {
  return function (runtime, state, builder) {
    return 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    i