Class Scope

packages/compiler/src/typecheck/ops/scope.ts:84–1051

 * If a `TcbOp` requires the output of another, it can call `resolve()`.
 */
export class Scope {
  /**
   * A queue of operations which need to be performed to generate the TCB code for this scope.
   *
   * This array can contain either a `TcbOp` which has yet to be executed, or a `TcbExpr|null`
   * representing the memoized result of executing the operation. As operations are executed, their
   * results are written into the `opQueue`, overwriting the original operation.
   *
   * If an operation is in the process of being executed, it is temporarily overwritten here with
   * `INFER_TYPE_FOR_CIRCULAR_OP_EXPR`. This way, if a cycle is encountered where an operation
   * depends transitively on its own result, the inner operation will infer the least narrow type
   * that fits instead. This has the same semantics as TypeScript itself when types are referenced
   * circularly.
   */
  private opQueue: (TcbOp | TcbExpr | null)[] = [];

  /**
   * A map of `Element`s to the index of their `TcbElementOp` in the `opQueue`
   */
  private elementOpMap = new Map<Element, number>();

  /**
   * A map of `HostElement`s to the index of their `TcbHostElementOp` in the `opQueue`
   */
  private hostElementOpMap = new Map<HostElement, number>();

  /**
   * A map of `Component`s to the index of their `TcbComponentNodeOp` in the `opQueue`
   */
  private componentNodeOpMap = new Map<Component, number>();

  /**
   * A map of maps which tracks the index of `TcbDirectiveCtorOp`s in the `opQueue` for each
   * directive on a `Element` or `Template` node.
   */
  private directiveOpMap = new Map<DirectiveOwner, Map<TcbDirectiveMetadata, number>>();

  /**
   * A map of `Reference`s to the index of their `TcbReferenceOp` in the `opQueue`
   */
  private referenceOpMap = new Map<Reference, number>();

  /**
   * Map of immediately nested <ng-template>s (within this `Scope`) represented by `Template`
   * nodes to the index of their `TcbTemplateContextOp`s in the `opQueue`.
   */
  private templateCtxOpMap = new Map<Template, number>();

  /**
   * Map of variables declared on the template that created this `Scope` (represented by
   * `Variable` nodes) to the index of their `TcbVariableOp`s in the `opQueue`, or to
   * pre-resolved variable identifiers.
   */
  private varMap = new Map<Variable, number | TcbExpr>();

  /**
   * A map of the names of `LetDeclaration`s to the index of their op in the `opQueue`.
   *