This modifies our down-level emit for async functions when they contain non-trivial parameter lists that may potentially throw when bound. Prior to this change, the following would throw immediately when it should instead produce a rejected promise:

// @target: es2015
// @lib: esnext
async function f(x, y = doesNotExist) {}
f();

The reason for this is that we eagerly evaluate the parameter list in the down-level emit:

function f(x, y = doesNotExist) {
  return __awaiter(this, void 0, void 0, function*() {});
}

To address this, this PR repurposes the second parameter to __awaiter, which was previously only used to bind a lexically-captured arguments, to instead be used to forward arguments for the function to the down-level generator body, producing the following emit instead:

function f(x_1) {
  return __awaiter(this, arguments, void 0, function*(x, y = doesNotExist) {});
}

When the transformed function is not an arrow function, we merely forward the function's arguments and emit placeholders for each fixed parameter to preserve the function's length, as can be seen with x_1 above.

Arrow functions, however, do not have their own arguments. In that case, we instead capture all fixed arguments, followed by a rest parameter that holds any additional arguments.

Thus,

const f = async (x, y = doesNotExist) => {};

now transforms to

const f = (x_1, ...args_1) => __awaiter(this, [x_1, ...args_1], void 0, function*(x, y = doesNotExist) {});

This change means that we can no longer rely on the previous mechanism for lexical arguments capturing (i.e., just passing it along as the second parameter to __awaiter), and instead must manually capture a lexical arguments binding.

Thus,

function f() {
  return async (x, y = doesNotExist) => arguments.length;
}

now transforms to

function f() {
  return (x_1, ...args_1) => {
    var arguments_1 = arguments;
    return __awaiter(this, [x_1, ...args_1], void 0, function* (x, y = doesNotExist) {
      return arguments_1.length;
    });
  };
}

Aside from the change to lexical arguments capturing, a function with a trivial parameter list does not undergo this transformation.

Thus,

async function f(x, y) {}

still transforms to

function f(x, y) { return __awaiter(this, void 0, void 0, function*() {}); }

in an effort to limit the complexity of the down-level emit when it is unwarranted.

It should also be noted that this PR applies a similar change to async generators as well.

Fixes #40410