sdk/tests/web/wasm/callback_test.dart

// Copyright (c) 2022, 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.

// dart2wasmOptions=--extra-compiler-option=--enable-experimental-wasm-interop

import 'dart:_wasm';
import 'dart:js_util';

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

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

typedef SumTwoPositionalFun = String Function(String a, String b);
typedef SumOnePositionalAndOneOptionalFun =
    String Function(String a, [String? b]);
typedef SumTwoOptionalFun = String Function([String? a, String? b]);
typedef SumOnePositionalAndOneOptionalNonNullFun =
    String Function(String a, [String b]);
typedef SumTwoOptionalNonNullFun = String Function([String a, String b]);

@JS()
@staticInterop
class DartFromJSCallbackHelper {
  external factory DartFromJSCallbackHelper.factory(
    SumTwoPositionalFun sumTwoPositional,
    SumOnePositionalAndOneOptionalFun sumOnePositionalOneOptional,
    SumTwoOptionalFun sumTwoOptional,
    SumOnePositionalAndOneOptionalNonNullFun
    sumOnePositionalAndOneOptionalNonNull,
    SumTwoOptionalNonNullFun sumTwoOptionalNonNull,
  );
}

extension DartFromJSCallbackHelperMethods on DartFromJSCallbackHelper {
  external String doSum1();
  external String doSum2(String a, String b);
  external String doSum3(Object summer);

  external String doSumOnePositionalAndOneOptionalA(String a);
  external String doSumOnePositionalAndOneOptionalB(String a, String b);
  external String doSumTwoOptionalA();
  external String doSumTwoOptionalB(String a);
  external String doSumTwoOptionalC(String a, String b);

  external String doSumOnePositionalAndOneOptionalANonNull(String a);
  external String doSumOnePositionalAndOneOptionalBNonNull(String a, String b);
  external String doSumTwoOptionalANonNull();
  external String doSumTwoOptionalBNonNull(String a);
  external String doSumTwoOptionalCNonNull(String a, String b);
}

String sumTwoPositional(String a, String b) {
  return a + b;
}

String sumOnePositionalAndOneOptional(String a, [String? b]) {
  return a + (b ?? 'bar');
}

String sumTwoOptional([String? a, String? b]) {
  return (a ?? 'foo') + (b ?? 'bar');
}

String sumOnePositionalAndOneOptionalNonNull(String a, [String b = 'bar']) {
  return a + b;
}

String sumTwoOptionalNonNull([String a = 'foo', String b = 'bar']) {
  return a + b;
}

void staticInteropCallbackTest() {
  eval(r'''
    globalThis.DartFromJSCallbackHelper = function(
        sumTwoPositional, sumOnePositionalOneOptional, sumTwoOptional,
        sumOnePositionalAndOneOptionalNonNull, sumTwoOptionalNonNull) {
      this.a = 'hello ';
      this.b = 'world!';
      this.sum = null;
      this.sumTwoPositional = sumTwoPositional;
      this.sumOnePositionalOneOptional = sumOnePositionalOneOptional;
      this.sumTwoOptional = sumTwoOptional;
      this.sumOnePositionalAndOneOptionalNonNull = sumOnePositionalAndOneOptionalNonNull;
      this.sumTwoOptionalNonNull = sumTwoOptionalNonNull;
      this.doSum1 = () => {
        return this.sumTwoPositional(this.a, this.b);
      }
      this.doSum2 = (a, b) => {
        return this.sumTwoPositional(a, b);
      }
      this.doSum3 = (summer) => {
        return summer(this.a, this.b);
      }
      this.doSumOnePositionalAndOneOptionalA = (a) => {
        return sumOnePositionalOneOptional(a);
      }
      this.doSumOnePositionalAndOneOptionalB = (a, b) => {
        return sumOnePositionalOneOptional(a, b);
      }
      this.doSumTwoOptionalA = () => {
        return sumTwoOptional();
      }
      this.doSumTwoOptionalB = (a) => {
        return sumTwoOptional(a);
      }
      this.doSumTwoOptionalC = (a, b) => {
        return sumTwoOptional(a, b);
      }
      this.doSumOnePositionalAndOneOptionalANonNull = (a) => {
        return sumOnePositionalAndOneOptionalNonNull(a);
      }
      this.doSumOnePositionalAndOneOptionalBNonNull = (a, b) => {
        return sumOnePositionalAndOneOptionalNonNull(a, b);
      }
      this.doSumTwoOptionalANonNull = () => {
        return sumTwoOptionalNonNull();
      }
      this.doSumTwoOptionalBNonNull = (a) => {
        return sumTwoOptionalNonNull(a);
      }
      this.doSumTwoOptionalCNonNull = (a, b) => {
        return sumTwoOptionalNonNull(a, b);
      }

    }
  ''');

  final helper = DartFromJSCallbackHelper.factory(
    allowInterop<SumTwoPositionalFun>(sumTwoPositional),
    allowInterop<SumOnePositionalAndOneOptionalFun>(
      sumOnePositionalAndOneOptional,
    ),
    allowInterop<SumTwoOptionalFun>(sumTwoOptional),
    allowInterop<SumOnePositionalAndOneOptionalNonNullFun>(
      sumOnePositionalAndOneOptionalNonNull,
    ),
    allowInterop<SumTwoOptionalNonNullFun>(sumTwoOptionalNonNull),
  );

  Expect.equals('hello world!', helper.doSum1());
  Expect.equals('foobar', helper.doSum2('foo', 'bar'));
  Expect.equals(
    'hello world!',
    helper.doSum3(allowInterop<SumTwoPositionalFun>((a, b) => a + b)),
  );

  Expect.equals('foobar', helper.doSumOnePositionalAndOneOptionalA('foo'));
  Expect.equals(
    'foobar',
    helper.doSumOnePositionalAndOneOptionalB('foo', 'bar'),
  );
  Expect.equals('foobar', helper.doSumTwoOptionalA());
  Expect.equals('foobar', helper.doSumTwoOptionalB('foo'));
  Expect.equals('foobar', helper.doSumTwoOptionalC('foo', 'bar'));

  Expect.equals(
    'foobar',
    helper.doSumOnePositionalAndOneOptionalANonNull('foo'),
  );
  Expect.equals(
    'foobar',
    helper.doSumOnePositionalAndOneOptionalBNonNull('foo', 'bar'),
  );
  Expect.equals('foobar', helper.doSumTwoOptionalANonNull());
  Expect.equals('foobar', helper.doSumTwoOptionalBNonNull('foo'));
  Expect.equals('foobar', helper.doSumTwoOptionalCNonNull('foo', 'bar'));
}

typedef NoArgsFun = String Function();
typedef OneArgFun = String Function(String arg);
typedef OnePositionalAndOneOptionalArgsFun =
    String Function(String arg, [String arg2]);
typedef TwoOptionalArgsFun = String Function([String arg, String arg2]);

class TornOffClass {
  String noArgs() {
    return 'foo';
  }

  String oneArg(String arg) {
    return arg;
  }

  String onePositionalAndOneOptionalArgs(String arg, [String arg2 = 'bar']) {
    return arg + arg2;
  }

  String twoOptionalArgs([String arg = 'foo', String? arg2]) {
    return arg + (arg2 ?? '');
  }
}

typedef OneArgFunB = String Function(double arg);
typedef OnePositionalAndOneOptionalArgsFunB =
    String Function(double arg, [String arg2]);
typedef TwoOptionalArgsFunB = String Function([double arg, String arg2]);

class GenericTornOffClass<T, V> {
  String noArgs() {
    return 'foo';
  }

  String oneArg(T arg) {
    return '$arg';
  }

  String onePositionalAndOneOptionalArgs(T arg, [V? arg2]) {
    return '$arg $arg2';
  }

  String twoOptionalArgs([T? arg, V? arg2]) {
    return '$arg $arg2';
  }
}

void allowInteropCallbackTest() {
  eval(r'''
    globalThis.doSum1 = function(summer) {
      return summer('foo', 'bar');
    }
    globalThis.doSum2 = function(a, b) {
      return globalThis.summer(a, b);
    }
    globalThis.doSumOnePositionalAndOneOptionalA = function(a) {
      return summer(a);
    }
    globalThis.doSumOnePositionalAndOneOptionalB = function(a, b) {
      return summer(a, b);
    }
    globalThis.doSumTwoOptionalA = function() {
      return summer();
    }
    globalThis.doSumTwoOptionalB = function(a) {
      return summer(a);
    }
    globalThis.doSumTwoOptionalC = function(a, b) {
      return summer(a, b);
    }
    globalThis.doSumOnePositionalAndOneOptionalANonNull = function(a) {
      return summer(a);
    }
    globalThis.doSumOnePositionalAndOneOptionalBNonNull = function(a, b) {
      return summer(a, b);
    }
    globalThis.doSumTwoOptionalANonNull = function() {
      return summer();
    }
    globalThis.doSumTwoOptionalBNonNull = function(a) {
      return summer(a);
    }
    globalThis.doSumTwoOptionalCNonNull = function(a, b) {
      return summer(a, b);
    }

    // tear off cases
    globalThis.tearOffNoArgs = function (f) {
      return f();
    }
    globalThis.tearOffOneArg = function (f) {
      return f('foo');
    }
    globalThis.tearOffOnePositionalAndOneOptionalArgsA = function (f) {
      return f('foo');
    }
    globalThis.tearOffOnePositionalAndOneOptionalArgsB = function (f) {
      return f('foo', 'baz');
    }
    globalThis.tearOffTwoOptionalArgsA = function (f) {
      return f('foo');
    }
    globalThis.tearOffTwoOptionalArgsB = function (f) {
      return f('foo', 'baz');
    }

    // tear off generic class cases
    globalThis.tearOffGenericNoArgs = function (f) {
      return f();
    }
    globalThis.tearOffGenericOneArg = function (f) {
      return f(1.0);
    }
    globalThis.tearOffGenericOnePositionalAndOneOptionalArgsA = function (f) {
      return f(1.0);
    }
    globalThis.tearOffGenericOnePositionalAndOneOptionalArgsB = function (f) {
      return f(1.0, 'baz');
    }
    globalThis.tearOffGenericTwoOptionalArgsA = function (f) {
      return f(1.0);
    }
    globalThis.tearOffGenericTwoOptionalArgsB = function (f) {
      return f(1.0, 'baz');
    }
  ''');

  // General
  {
    final interopCallback = allowInterop<SumTwoPositionalFun>((a, b) => a + b);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSum1', [interopCallback]).toString(),
    );
    setProperty(globalThis, 'summer', interopCallback);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSum2', ['foo', 'bar']).toString(),
    );
    final roundTripCallback = getProperty(globalThis, 'summer');
    Expect.equals(
      'foobar',
      (dartify(roundTripCallback) as SumTwoPositionalFun)('foo', 'bar'),
    );
  }

  // 1 nullable optional argument
  {
    final interopCallback = allowInterop<SumOnePositionalAndOneOptionalFun>(
      (a, [b]) => a + (b ?? 'bar'),
    );
    setProperty(globalThis, 'summer', interopCallback);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumOnePositionalAndOneOptionalA', [
        'foo',
      ]).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumOnePositionalAndOneOptionalB', [
        'foo',
        'bar',
      ]).toString(),
    );
  }

  // All nullable optional arguments
  {
    final interopCallback = allowInterop<SumTwoOptionalFun>(
      ([a, b]) => (a ?? 'foo') + (b ?? 'bar'),
    );
    setProperty(globalThis, 'summer', interopCallback);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalA', []).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalB', ['foo']).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalC', ['foo', 'bar']).toString(),
    );
  }

  // 1 non-nullable optional argument
  {
    final interopCallback =
        allowInterop<SumOnePositionalAndOneOptionalNonNullFun>(
          (a, [b = 'bar']) => a + b,
        );
    setProperty(globalThis, 'summer', interopCallback);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumOnePositionalAndOneOptionalA', [
        'foo',
      ]).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumOnePositionalAndOneOptionalB', [
        'foo',
        'bar',
      ]).toString(),
    );
  }

  // All non-nullable optional arguments
  {
    final interopCallback = allowInterop<SumTwoOptionalNonNullFun>(
      ([a = 'foo', b = 'bar']) => a + b,
    );
    setProperty(globalThis, 'summer', interopCallback);
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalA', []).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalB', ['foo']).toString(),
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'doSumTwoOptionalC', ['foo', 'bar']).toString(),
    );
  }

  // Tear off cases
  // No args.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<NoArgsFun>(t.noArgs);
    Expect.equals(
      'foo',
      callMethod(globalThis, 'tearOffNoArgs', [interopCallback]),
    );
  }

  // One arg.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<OneArgFun>(t.oneArg);
    Expect.equals(
      'foo',
      callMethod(globalThis, 'tearOffOneArg', [interopCallback]),
    );
  }

  // One positional and one optional case A.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<OnePositionalAndOneOptionalArgsFun>(
      t.onePositionalAndOneOptionalArgs,
    );
    Expect.equals(
      'foobar',
      callMethod(globalThis, 'tearOffOnePositionalAndOneOptionalArgsA', [
        interopCallback,
      ]),
    );
  }

  // One positional and one optional case B.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<OnePositionalAndOneOptionalArgsFun>(
      t.onePositionalAndOneOptionalArgs,
    );
    Expect.equals(
      'foobaz',
      callMethod(globalThis, 'tearOffOnePositionalAndOneOptionalArgsB', [
        interopCallback,
      ]),
    );
  }

  // Two optional case A.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<TwoOptionalArgsFun>(t.twoOptionalArgs);
    Expect.equals(
      'foo',
      callMethod(globalThis, 'tearOffTwoOptionalArgsA', [interopCallback]),
    );
  }

  // Two optional case B.
  {
    final t = TornOffClass();
    final interopCallback = allowInterop<TwoOptionalArgsFun>(t.twoOptionalArgs);
    Expect.equals(
      'foobaz',
      callMethod(globalThis, 'tearOffTwoOptionalArgsB', [interopCallback]),
    );
  }

  // Tearoffs of generic classes.
  // No args.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<NoArgsFun>(t.noArgs);
    Expect.equals(
      'foo',
      callMethod(globalThis, 'tearOffGenericNoArgs', [interopCallback]),
    );
  }

  // One arg.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<OneArgFunB>(t.oneArg);
    Expect.equals(
      '1.0',
      callMethod(globalThis, 'tearOffGenericOneArg', [interopCallback]),
    );
  }

  // One positional and one optional case A.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<OnePositionalAndOneOptionalArgsFunB>(
      t.onePositionalAndOneOptionalArgs,
    );
    Expect.equals(
      '1.0 null',
      callMethod(globalThis, 'tearOffGenericOnePositionalAndOneOptionalArgsA', [
        interopCallback,
      ]),
    );
  }

  // One positional and one optional case B.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<OnePositionalAndOneOptionalArgsFunB>(
      t.onePositionalAndOneOptionalArgs,
    );
    Expect.equals(
      '1.0 baz',
      callMethod(globalThis, 'tearOffGenericOnePositionalAndOneOptionalArgsB', [
        interopCallback,
      ]),
    );
  }

  // Two optional case A.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<TwoOptionalArgsFunB>(
      t.twoOptionalArgs,
    );
    Expect.equals(
      '1.0 null',
      callMethod(globalThis, 'tearOffGenericTwoOptionalArgsA', [
        interopCallback,
      ]),
    );
  }

  // Two optional case B.
  {
    final t = GenericTornOffClass<double, String>();
    final interopCallback = allowInterop<TwoOptionalArgsFunB>(
      t.twoOptionalArgs,
    );
    Expect.equals(
      '1.0 baz',
      callMethod(globalThis, 'tearOffGenericTwoOptionalArgsB', [
        interopCallback,
      ]),
    );
  }
}

void main() {
  staticInteropCallbackTest();
  allowInteropCallbackTest();
}