Method forNodes

packages/compiler/src/typecheck/ops/scope.ts:184–266

* Constructs a `Scope` given either a `Template` or a list of `Node`s. * * @param tcb the overall context of TCB generation. * @param parentScope the `Scope` of the parent template (if any) or `null` if this is the root * `Scope`. * @param scopedNode Node that provides the scope aroun

(
    tcb: Context,
    parentScope: Scope | null,
    scopedNode: Template | IfBlockBranch | ForLoopBlock | HostElement | null,
    children: Node[] | null,
    guard: TcbExpr | null,
  )

   * @param guard an expression that is applied to this scope for type narrowing purposes.
   */
  static forNodes(
    tcb: Context,
    parentScope: Scope | null,
    scopedNode: Template | IfBlockBranch | ForLoopBlock | HostElement | null,
    children: Node[] | null,
    guard: TcbExpr | null,
  ): Scope {
    const scope = new Scope(tcb, parentScope, guard);

    if (parentScope === null && tcb.env.config.enableTemplateTypeChecker) {
      // Add an autocompletion point for the component context.
      scope.opQueue.push(new TcbComponentContextCompletionOp(scope));
    }

    // If given an actual `Template` instance, then process any additional information it
    // has.
    if (scopedNode instanceof Template) {
      // The template's variable declarations need to be added as `TcbVariableOp`s.
      const varMap = new Map<string, Variable>();

      for (const v of scopedNode.variables) {
        // Validate that variables on the `Template` are only declared once.
        if (!varMap.has(v.name)) {
          varMap.set(v.name, v);
        } else {
          const firstDecl = varMap.get(v.name)!;
          tcb.oobRecorder.duplicateTemplateVar(tcb.id, v, firstDecl);
        }
        Scope.registerVariable(scope, v, new TcbTemplateVariableOp(tcb, scope, scopedNode, v));
      }
    } else if (scopedNode instanceof IfBlockBranch) {
      const {expression, expressionAlias} = scopedNode;
      if (expression !== null && expressionAlias !== null) {
        Scope.registerVariable(
          scope,
          expressionAlias,
          new TcbBlockVariableOp(
            tcb,
            scope,
            tcbExpression(expression, tcb, scope),
            expressionAlias,
          ),
        );
      }
    } else if (scopedNode instanceof ForLoopBlock) {
      // Register the variable for the loop so it can be resolved by
      // children. It'll be declared once the loop is created.
      const loopInitializer = new TcbExpr(tcb.allocateId());
      loopInitializer.addParseSpanInfo(scopedNode.item.sourceSpan);
      scope.varMap.set(scopedNode.item, loopInitializer);

      const forLoopContextVariableTypes = Scope.getForLoopContextVariableTypes();

      for (const variable of scopedNode.contextVariables) {
        if (!forLoopContextVariableTypes.has(variable.value)) {
          throw new Error(`Unrecognized for loop context variable ${variable.name}`);
        }