tests/lib/js/static_interop_test/js_function_arity_test.dart

// Copyright (c) 2024, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// Requirements=checked-implicit-downcasts

import 'dart:js_interop';

import 'package:expect/expect.dart';
import 'package:expect/variations.dart';

const isDDC = const bool.fromEnvironment('dart.library._ddc_only');
const isDart2JS = const bool.fromEnvironment('dart.tool.dart2js');
const soundNullSafety = !unsoundNullSafety;

@JS('call')
external String _call(JSFunction f, JSArray<JSAny?> args);

String call(JSFunction f, List<Object?> args) =>
    _call(f, args.map((e) => e?.jsify()).toList().toJS);

@JS()
external void eval(String code);

// Zero.
String zeroArgs() => '0';
String zeroArgsThis([JSObject? this_]) => '0';

// One.
String oneRequired(String arg1) => arg1;
String oneOptional([String arg1 = 'default']) => '$arg1';
String oneOptionalThis(JSObject? this_, [String arg1 = 'default']) => '$arg1';

// Two.
String twoRequired(String arg1, String? arg2) => '$arg1$arg2';
String oneRequiredOneOptional(String arg1, [String? arg2 = 'default']) =>
    '$arg1$arg2';
String twoOptional([String arg1 = 'default', String? arg2 = 'default']) =>
    '$arg1$arg2';
String oneRequiredOneOptionalThis(
  JSObject? this_,
  String arg1, [
  String? arg2 = 'default',
]) => '$arg1$arg2';

// Three.
String threeRequired(String arg1, String? arg2, String arg3) =>
    '$arg1$arg2$arg3';
String twoRequiredOneOptional(
  String arg1,
  String? arg2, [
  String arg3 = 'default',
]) => '$arg1$arg2$arg3';
String oneRequiredTwoOptional(
  String arg1, [
  String? arg2 = 'default',
  String arg3 = 'default',
]) => '$arg1$arg2$arg3';
String threeOptional([
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
]) => '$arg1$arg2$arg3';
String threeOptionalThis([
  JSObject? this_,
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
]) => '$arg1$arg2$arg3';

// Four.
String fourRequired(String arg1, String? arg2, String arg3, String arg4) =>
    '$arg1$arg2$arg3$arg4';
String threeRequiredOneOptional(
  String arg1,
  String? arg2,
  String arg3, [
  String arg4 = 'default',
]) => '$arg1$arg2$arg3$arg4';
String twoRequiredTwoOptional(
  String arg1,
  String? arg2, [
  String arg3 = 'default',
  String arg4 = 'default',
]) => '$arg1$arg2$arg3$arg4';
String oneRequiredThreeOptional(
  String arg1, [
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
]) => '$arg1$arg2$arg3$arg4';
String fourOptional([
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
]) => '$arg1$arg2$arg3$arg4';
String oneRequiredThreeOptionalThis(
  JSObject? this_,
  String arg1, [
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
]) => '$arg1$arg2$arg3$arg4';

// Five.
String fiveRequired(
  String arg1,
  String? arg2,
  String arg3,
  String arg4,
  String arg5,
) => '$arg1$arg2$arg3$arg4$arg5';
String fourRequiredOneOptional(
  String arg1,
  String? arg2,
  String arg3,
  String arg4, [
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';
String threeRequiredTwoOptional(
  String arg1,
  String? arg2,
  String arg3, [
  String arg4 = 'default',
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';
String twoRequiredThreeOptional(
  String arg1,
  String? arg2, [
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';
String oneRequiredFourOptional(
  String arg1, [
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';
String fiveOptional([
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';
String threeRequiredTwoOptionalThis(
  JSObject? this_,
  String arg1,
  String? arg2,
  String arg3, [
  String arg4 = 'default',
  String arg5 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5';

// Six.
String sixRequired(
  String arg1,
  String? arg2,
  String arg3,
  String arg4,
  String arg5,
  String arg6,
) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String fiveRequiredOneOptional(
  String arg1,
  String? arg2,
  String arg3,
  String arg4,
  String arg5, [
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String fourRequiredTwoOptional(
  String arg1,
  String? arg2,
  String arg3,
  String arg4, [
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String threeRequiredThreeOptional(
  String arg1,
  String? arg2,
  String arg3, [
  String arg4 = 'default',
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String twoRequiredFourOptional(
  String arg1,
  String? arg2, [
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String oneRequiredFiveOptional(
  String arg1, [
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String sixOptional([
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';
String sixOptionalThis([
  JSObject? this_,
  String arg1 = 'default',
  String? arg2 = 'default',
  String arg3 = 'default',
  String arg4 = 'default',
  String arg5 = 'default',
  String arg6 = 'default',
]) => '$arg1$arg2$arg3$arg4$arg5$arg6';

void testZero() {
  // Arity tests.
  Expect.equals(call(zeroArgs.toJS, []), '0');
  Expect.equals(call(zeroArgs.toJS, ['extra']), '0');
  Expect.equals(call(zeroArgs.toJS, [1.0]), '0');
  Expect.equals(call(zeroArgsThis.toJSCaptureThis, []), '0');
  Expect.equals(call(zeroArgs.toJSCaptureThis, []), '0');

  // Conversion round-trip test.
  final tearOff = zeroArgs;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = zeroArgsThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(() => (zeroArgs.toJS as String Function()).toJS);
    Expect.throwsArgumentError(
      () => (zeroArgsThis.toJSCaptureThis as String Function()).toJSCaptureThis,
    );
  }
}

void testOne() {
  // Type tests.
  Expect.throws(() => call(oneRequired.toJS, [0]));
  Expect.throwsWhen(soundNullSafety, () => call(oneOptional.toJS, [null]));
  Expect.throwsWhen(
    soundNullSafety,
    () => call(oneOptional.toJS, ['undefined']),
  );
  Expect.throws(() => call(oneOptionalThis.toJSCaptureThis, [true]));

  // Arity tests.
  Expect.throws(() => call(oneRequired.toJS, []));
  Expect.equals(call(oneRequired.toJS, ['a']), 'a');
  Expect.equals(call(oneRequired.toJS, ['a', 'extra']), 'a');
  Expect.equals(call(oneOptional.toJS, []), 'default');
  Expect.equals(call(oneOptional.toJS, ['a']), 'a');
  Expect.equals(call(oneOptional.toJS, ['a', 'extra']), 'a');
  Expect.equals(call(oneOptionalThis.toJSCaptureThis, ['a']), 'a');
  if (soundNullSafety) {
    // `this` can be null or a JSObject depending on strict mode, which in turn
    // depends on the compiler. To make this consistent, only run when sound
    // null safety is enabled.
    Expect.throws(() => call(oneRequired.toJSCaptureThis, []));
  }

  // Function subtyping tests.
  Expect.equals(call((oneOptional as String Function()).toJS, []), 'default');
  // Throws away the additional args due to the static typing.
  Expect.equals(
    call((oneOptional as String Function()).toJS, ['a']),
    'default',
  );
  Expect.equals(
    call((oneOptionalThis as String Function(JSObject?)).toJSCaptureThis, [
      'a',
    ]),
    'default',
  );

  // Conversion round-trip test.
  final tearOff = oneRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = oneOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (oneOptional.toJS as String Function()).toJS,
    );
    Expect.throwsArgumentError(
      () => (oneOptionalThis.toJSCaptureThis as String Function(JSObject?))
          .toJSCaptureThis,
    );
  }
}

void testTwo() {
  // Type tests.
  Expect.throws(() => call(twoOptional.toJS, [false, 'b']));
  Expect.throws(() => call(twoOptional.toJS, ['a', 1.0]));
  Expect.throwsWhen(
    soundNullSafety,
    () => call(oneRequiredOneOptional.toJS, ['undefined', 'b']),
  );
  Expect.throws(() => call(oneRequiredOneOptional.toJS, ['a', true]));
  Expect.throws(() => call(twoRequired.toJS, [0, 'b']));
  Expect.throws(() => call(twoRequired.toJS, ['a', 0]));
  Expect.throws(() => call(oneRequiredOneOptional.toJSCaptureThis, [0]));

  // Arity tests.
  Expect.throws(() => call(twoRequired.toJS, []));
  Expect.throws(() => call(twoRequired.toJS, ['a']));
  Expect.equals(call(twoRequired.toJS, ['a', 'b']), 'ab');
  Expect.equals(call(twoRequired.toJS, ['a', 'b', 'extra']), 'ab');
  Expect.throws(() => call(oneRequiredOneOptional.toJS, []));
  Expect.equals(call(oneRequiredOneOptional.toJS, ['a']), 'adefault');
  Expect.equals(call(oneRequiredOneOptional.toJS, ['a', 'b']), 'ab');
  Expect.equals(call(oneRequiredOneOptional.toJS, ['a', 'b', 'extra']), 'ab');
  Expect.equals(call(twoOptional.toJS, []), 'defaultdefault');
  Expect.equals(call(twoOptional.toJS, ['a']), 'adefault');
  Expect.equals(call(twoOptional.toJS, ['a', 'b']), 'ab');
  Expect.equals(call(twoOptional.toJS, ['a', 'b', 'extra']), 'ab');
  Expect.equals(
    call(oneRequiredOneOptionalThis.toJSCaptureThis, ['a', 'b', 'extra']),
    'ab',
  );
  Expect.equals(
    call(oneRequiredOneOptionalThis.toJSCaptureThis, ['a']),
    'adefault',
  );

  // Function subtyping tests.
  // TODO(55881): dart2wasm's type conversions are based on the static type,
  // whereas DDC and dart2js only do type checks based on the runtime type. We
  // can't replicate dart2Wasm's behavior in DDC and dart2js as it would require
  // a new Dart trampoline for every function, so there's a discrepancy when we
  // use a static type with different parameter types.
  var closure = () =>
      call((twoRequired as String Function(String, String)).toJS, ['a', null]);
  if (isDDC || isDart2JS) {
    Expect.equals(closure(), 'anull');
  } else {
    Expect.throws(closure);
  }
  Expect.throws(
    () => call((oneRequiredOneOptional as String Function(String)).toJS, []),
  );
  Expect.equals(
    call((oneRequiredOneOptional as String Function(String)).toJS, ['a']),
    'adefault',
  );
  Expect.equals(
    call((oneRequiredOneOptional as String Function(String)).toJS, ['a', 0]),
    'adefault',
  );
  Expect.equals(
    call((twoOptional as String Function()).toJS, []),
    'defaultdefault',
  );
  Expect.equals(
    call((twoOptional as String Function()).toJS, ['a']),
    'defaultdefault',
  );
  Expect.equals(
    call((twoOptional as String Function([String])).toJS, []),
    'defaultdefault',
  );
  Expect.equals(
    call((twoOptional as String Function([String])).toJS, ['a']),
    'adefault',
  );
  Expect.equals(
    call((twoOptional as String Function([String])).toJS, ['a', false]),
    'adefault',
  );
  Expect.equals(
    call(
      (oneRequiredOneOptionalThis as String Function(JSObject?, String))
          .toJSCaptureThis,
      ['a', 'b'],
    ),
    'adefault',
  );

  // `undefined` tests.
  Expect.equals(call(twoRequired.toJS, ['a', 'undefined']), 'anull');
  // TODO(55884): DDC lowers function with defaults to use the JS default
  // argument syntax, which means passing `undefined` results in DDC replacing
  // it with the default, instead of keeping it as `undefined`.
  Expect.equals(
    call(oneRequiredOneOptional.toJS, ['a', 'undefined']),
    isDDC ? 'adefault' : 'anull',
  );
  Expect.equals(
    call(twoOptional.toJS, ['a', 'undefined']),
    isDDC ? 'adefault' : 'anull',
  );

  // Conversion round-trip test.
  final tearOff = twoRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = oneRequiredOneOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (oneRequiredOneOptional.toJS as String Function(String)).toJS,
    );
    Expect.throwsArgumentError(
      () =>
          (oneRequiredOneOptionalThis.toJSCaptureThis
                  as String Function(JSObject?, String))
              .toJSCaptureThis,
    );
  }
}

// To avoid making this test unreadably long, the remaining tests choose a small
// subset of all possible tests for general validation.
void testThree() {
  // Type tests.
  Expect.throws(() => call(threeRequired.toJS, [0, 'b', 'c']));
  Expect.throws(() => call(oneRequiredTwoOptional.toJS, ['a', false]));
  Expect.throws(() => call(threeOptionalThis.toJSCaptureThis, [true]));

  // Arity tests.
  Expect.equals(call(twoRequiredOneOptional.toJS, ['a', 'b']), 'abdefault');
  Expect.throws(() => call(oneRequiredTwoOptional.toJS, []));
  Expect.equals(
    call(threeOptionalThis.toJSCaptureThis, ['a', 'b']),
    'abdefault',
  );

  // Function subtyping tests.
  var closure = () => call(
    (twoRequiredOneOptional as String Function(String, String)).toJS,
    ['a', null, 'c'],
  );
  if (isDDC || isDart2JS) {
    Expect.equals(closure(), 'anulldefault');
  } else {
    Expect.throws(closure);
  }
  Expect.equals(
    call((threeOptional as String Function([String])).toJS, ['a', 0, true]),
    'adefaultdefault',
  );
  Expect.equals(
    call(
      (threeOptionalThis as String Function([JSObject?, String, String?]))
          .toJSCaptureThis,
      ['a', 'b', false],
    ),
    'abdefault',
  );

  // `undefined` tests.
  Expect.equals(
    call(threeOptional.toJS, ['a', 'undefined']),
    isDDC ? 'adefaultdefault' : 'anulldefault',
  );

  // Conversion round-trip test.
  final tearOff = threeRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = threeOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (twoRequiredOneOptional.toJS as String Function(String, String?))
          .toJS,
    );
    Expect.throwsArgumentError(
      () => (threeOptionalThis.toJSCaptureThis as String Function(JSObject?))
          .toJSCaptureThis,
    );
  }
}

void testFour() {
  // Type tests.
  Expect.throws(
    () => call(threeRequiredOneOptional.toJS, ['a', 'b', 'c', true]),
  );
  Expect.throws(() => call(oneRequiredThreeOptional.toJS, [false]));
  if (soundNullSafety) {
    // `this` can be null or a JSObject depending on strict mode, which in turn
    // depends on the compiler. To make this consistent, only run when sound
    // null safety is enabled.
    Expect.throws(() => call(oneRequiredThreeOptional.toJSCaptureThis, ['a']));
  }

  // Arity tests.
  Expect.equals(call(fourRequired.toJS, ['a', 'b', 'c', 'd', false]), 'abcd');
  Expect.equals(call(fourOptional.toJS, ['a']), 'adefaultdefaultdefault');
  Expect.equals(
    call(oneRequiredThreeOptionalThis.toJSCaptureThis, ['a', 'b']),
    'abdefaultdefault',
  );

  // Function subtyping tests.
  final closure = () => call(
    (threeRequiredOneOptional as String Function(String, String, String)).toJS,
    ['a', null, 'c'],
  );
  if (isDDC || isDart2JS) {
    Expect.equals(closure(), 'anullcdefault');
  } else {
    Expect.throws(closure);
  }
  Expect.equals(
    call(
      (twoRequiredTwoOptional as String Function(String, String?, [String]))
          .toJS,
      ['a', null],
    ),
    'anulldefaultdefault',
  );
  Expect.equals(
    call(
      (oneRequiredThreeOptionalThis as String Function(JSObject?, String))
          .toJSCaptureThis,
      ['a', 'b'],
    ),
    'adefaultdefaultdefault',
  );

  // `undefined` tests.
  Expect.equals(
    call(oneRequiredThreeOptional.toJS, ['a', 'undefined', 'c']),
    isDDC ? 'adefaultcdefault' : 'anullcdefault',
  );

  // Conversion round-trip test.
  final tearOff = fourRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = oneRequiredThreeOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (oneRequiredThreeOptional.toJS as String Function(String)).toJS,
    );
    Expect.throwsArgumentError(
      () =>
          (oneRequiredThreeOptionalThis.toJSCaptureThis
                  as String Function(JSObject?, String))
              .toJSCaptureThis,
    );
  }
}

void testFive() {
  // Type tests.
  Expect.throws(() => call(twoRequiredThreeOptional.toJS, ['a', 0]));
  Expect.throws(() => call(fiveOptional.toJS, [false]));
  Expect.throws(
    () => call(threeRequiredTwoOptionalThis.toJSCaptureThis, ['a', 'b', 1.0]),
  );

  // Arity tests.
  Expect.equals(call(fiveRequired.toJS, ['a', 'b', 'c', 'd', 'e', 0]), 'abcde');
  Expect.equals(
    call(fourRequiredOneOptional.toJS, ['a', null, 'c', 'd']),
    'anullcddefault',
  );
  Expect.equals(
    call(threeRequiredTwoOptionalThis.toJSCaptureThis, ['a', 'b', 'c', 'd']),
    'abcddefault',
  );

  // Function subtyping tests.
  final closure = () => call(
    (threeRequiredTwoOptional
            as String Function(String, String, String, [String]))
        .toJS,
    ['a', null, 'c'],
  );
  if (isDDC || isDart2JS) {
    Expect.equals(closure(), 'anullcdefaultdefault');
  } else {
    Expect.throws(closure);
  }
  Expect.equals(
    call(
      (twoRequiredThreeOptional as String Function(String, String?, [String]))
          .toJS,
      ['a', null, 'c'],
    ),
    'anullcdefaultdefault',
  );
  Expect.equals(
    call(
      (threeRequiredTwoOptionalThis
              as String Function(JSObject?, String, String?, String))
          .toJSCaptureThis,
      ['a', 'b', 'c', 'd'],
    ),
    'abcdefaultdefault',
  );

  // `undefined` tests.
  Expect.equals(
    call(oneRequiredFourOptional.toJS, ['a', 'undefined', 'c', 'd', 'e']),
    isDDC ? 'adefaultcde' : 'anullcde',
  );

  // Conversion round-trip test.
  final tearOff = fiveRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = threeRequiredTwoOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (twoRequiredThreeOptional.toJS as String Function(String, String?))
          .toJS,
    );
    Expect.throwsArgumentError(
      () =>
          (threeRequiredTwoOptionalThis.toJSCaptureThis
                  as String Function(JSObject?, String, String?, String))
              .toJSCaptureThis,
    );
  }
}

// DDC and dart2js should use either a `dcall` or `Function.apply` for this.
void testSix() {
  // Type tests.
  Expect.throws(() => call(sixRequired.toJS, ['a', 'b', 0.0, 'd', 'e', 'f']));
  Expect.throws(() => call(threeRequiredThreeOptional.toJS, ['undefined']));
  Expect.throwsWhen(
    soundNullSafety,
    () => call(sixOptionalThis.toJSCaptureThis, [null]),
  );

  // Arity tests.
  // Verify that we appropriately truncate arguments even though we don't have
  // a special lowering for six arguments in DDC and dart2js.
  Expect.equals(
    call(fourRequiredTwoOptional.toJS, ['a', 'b', 'c', 'd', 'e', 'f', 0]),
    'abcdef',
  );
  Expect.throws(() => call(twoRequiredFourOptional.toJS, []));
  Expect.equals(
    call(sixOptionalThis.toJSCaptureThis, ['a', 'b', 'c', 'd', 'e', 'f', 0]),
    'abcdef',
  );

  // Function subtyping tests.
  var closure = () => call(
    (fiveRequiredOneOptional
            as String Function(String, String, String, String, String))
        .toJS,
    ['a', null, 'c', 'd', 'e', 'f'],
  );
  if (isDDC || isDart2JS) {
    Expect.equals(closure(), 'anullcdedefault');
  } else {
    Expect.throws(closure);
  }
  Expect.equals(
    call((oneRequiredFiveOptional as String Function(String, [String?])).toJS, [
      'a',
      'b',
      0,
      0.0,
      false,
    ]),
    'abdefaultdefaultdefaultdefault',
  );
  Expect.equals(
    call((sixOptionalThis as String Function()).toJSCaptureThis, [
      true,
      0,
      0.0,
    ]),
    'defaultdefaultdefaultdefaultdefaultdefault',
  );

  // `undefined` tests.
  Expect.equals(
    call(sixOptional.toJS, ['a', 'undefined', 'c', 'd', 'e']),
    isDDC ? 'adefaultcdedefault' : 'anullcdedefault',
  );

  // Conversion round-trip test.
  final tearOff = sixRequired;
  Expect.identical(tearOff, tearOff.toJS.toDart);
  final tearOffThis = sixOptionalThis;
  Expect.identical(tearOffThis, tearOffThis.toJSCaptureThis.toDart);

  // Avoid rewrapping test.
  if (isDDC || isDart2JS) {
    Expect.throwsArgumentError(
      () => (sixOptional.toJS as String Function()).toJS,
    );
    Expect.throwsArgumentError(
      () => (sixOptionalThis.toJSCaptureThis as String Function(JSObject?))
          .toJSCaptureThis,
    );
  }
}

void main() {
  eval('''
    self.call = function(f, args) {
      var convert = function(arg) {
        return arg == 'undefined' ? undefined : arg;
      };
      return f.apply(null, args.map((e) => convert(e)));
    };
  ''');
  testZero();
  testOne();
  testTwo();
  testThree();
  testFour();
  testFive();
  testSix();
}