code: Node createJSCompMakeAsyncIteratorCall(Node iterable, Scope scope) {
      Node makeIteratorAsyncName = createQName(scope, "$jscomp.makeAsyncIterator");
      // Since createCall (currently) doesn't handle templated functions, fill in the template types
      // of makeIteratorName manually.
      if (isAddingTypes() && !makeIteratorAsyncName.getJSType().isUnknownType()) {
        // if makeIteratorName has the unknown type, we must have not injected the required runtime
        // libraries - hopefully because this is in a test using NonInjectingCompiler.
  
        // e.g get `number` from `AsyncIterable<number>`
        JSType asyncIterableType =
            JsIterables.maybeBoxIterableOrAsyncIterable(iterable.getJSType(), registry)
                .orElse(unknownType);
        JSType makeAsyncIteratorType = makeIteratorAsyncName.getJSType();
        // e.g. replace
        //   function(AsyncIterable<T>): AsyncIterator<T>
        // with
        //   function(AsyncIterable<number>): AsyncIterator<number>
        TemplateTypeMap typeMap =
            registry.createTemplateTypeMap(
                makeAsyncIteratorType.getTemplateTypeMap().getTemplateKeys(),
                ImmutableList.of(asyncIterableType));
        TemplateTypeMapReplacer replacer = new TemplateTypeMapReplacer(registry, typeMap);
        makeIteratorAsyncName.setJSType(makeAsyncIteratorType.visit(replacer));
      }
      return createCall(makeIteratorAsyncName, iterable);
    }
docs: Given an iterable like {@code rhs} in
  
  <pre>{@code
  for await (lhs of rhs) { block(); }
  }</pre>
  
  <p>returns a call node for the {@code rhs} wrapped in a {@code $jscomp.makeAsyncIterator} call.
  
  <pre>{@code
  $jscomp.makeAsyncIterator(rhs)
  }</pre>