implicit-call-tearoffs

import 'dart:async';

class Callable {
  const Callable();
  void call() {}
}

class ConstructorExpectedTypes {
  final Function callback;
  final Function defaultCallback;

  const ConstructorExpectedTypes(
    Callable callback, {
    this.defaultCallback = const Callable(),
  }) : callback = callback;
}

void accept(Function callback) {}
void acceptNamed({required Function callback}) {}
Function returnTopLevel() => const Callable();
Function topLevelCallback = const Callable();
set topLevelSetter(Function value) {}

class Receiver {
  Receiver(Function callback, {required Function named});
  Receiver.named({required Function callback});

  Function fieldCallback = const Callable();
  static Function staticCallback = const Callable();
  set callbackSetter(Function value) {}
  static set staticSetter(Function value) {}

  void instance(Function callback, {required Function named}) {}
  static void staticMethod(Function callback, {required Function named}) {}

  Function returnMethod() => const Callable();

  void assignments(Callable callback) {
    Function localCallback = callback;
    localCallback = callback;
    fieldCallback = callback;
    this.fieldCallback = callback;
    Receiver.staticCallback = callback;
    topLevelCallback = callback;
    callbackSetter = callback;
    this.callbackSetter = callback;
    Receiver.staticSetter = callback;
    topLevelSetter = callback;
  }

  void methodCalls(Callable callback, Receiver receiver) {
    accept(callback);
    acceptNamed(callback: callback);
    instance(callback, named: callback.call);
    instance(callback.call, named: callback);
    this.instance(callback, named: callback.call);
    receiver.instance(callback.call, named: callback);
    Receiver.staticMethod(callback, named: callback.call);
    Receiver.staticMethod(callback.call, named: callback);
  }

  void constructorCalls(Callable callback) {
    Receiver(callback, named: callback.call);
    Receiver(callback.call, named: callback);
    new Receiver(callback, named: callback.call);
    Receiver.named(callback: callback);
  }

  void localCalls(Callable callback) {
    void localFunction(Function value, {required Function named}) {}
    localFunction(callback, named: callback.call);
    localFunction(callback.call, named: callback);

    void Function(Function, {required Function named}) functionValue = localFunction;
    functionValue(callback, named: callback.call);

    final inferredFunctionValue = localFunction;
    inferredFunctionValue(callback, named: callback.call);
  }

  void scoped(List<Callable> callbacks) {
    Function localReturn() => const Callable();
    localReturn();
    for (Callable callback in callbacks) {
      accept(callback);
    }
    try {
      throw const Callable();
    } on Callable catch (callback) {
      accept(callback);
    }
    final (Callable callback,) = (const Callable(),);
    accept(callback);
  }
}

class BaseReceiver {
  void inherited(Function callback) {}
  set inheritedSetter(Function callback) {}
}

class ChildReceiver extends BaseReceiver {
  void inheritedCalls(Callable callback) {
    inherited(callback);
    this.inherited(callback);
    inheritedSetter = callback;
    this.inheritedSetter = callback;
  }
}

void topLevelCalls(Callable callback, Receiver receiver) {
  Receiver(callback, named: callback.call);
  receiver.instance(callback, named: callback.call);
}

class ObjectReceiver {
  void accept(Object value) {}
}

class LexicalLookup extends ObjectReceiver {
  // Inherited members are not in lexical scope: the top-level `accept` wins.
  void topLevelShadowsInherited(Callable callback) {
    accept(callback);
  }
}

class MutableCallable {
  void call() {}
  int value = 0;
}

void outerCoercions(
  MutableCallable first,
  MutableCallable second,
  MutableCallable? nullable,
  bool condition,
) {
  void Function() conditional = condition ? first : second;
  void Function() cascade = first..value = 1;
  void Function() coalesced = nullable ?? second;
}

extension type CallableView(Callable value) implements Callable {}

void contextualCoercions(Callable callback, CallableView view) {
  void Function() extensionValue = view;
  var spread = <void Function()>[...[callback]];
  (void Function(), int) positional = (callback, 1);
  ({void Function() callback}) named = (callback: callback);
}

Future<void Function()> asyncReturn(Callable callback) async => callback;
Iterable<void Function()> generatorReturn(Callable callback) sync* {
  yield callback;
}

void boundedCoercion<T extends Callable>(T callback) {
  void Function() value = callback;
}

class GenericCallable {
  void call<T>(T value) {}
}

void acceptIntCallback(void Function(int) callback) {}

void instantiatedCoercions(GenericCallable callback) {
  Function functionContext = callback<int>;
  void Function(int) typedContext = callback<int>;
  acceptIntCallback(callback<int>);
  callback<int>;
  Function createdFunctionContext = GenericCallable()<int>;
  void Function(int) createdTypedContext = GenericCallable()<int>;
  acceptIntCallback(GenericCallable()<int>);
  GenericCallable()<int>;
}

void acceptFutureOrCallback(FutureOr<void Function()> callback) {}

void futureOrCoercion(Callable callback) {
  acceptFutureOrCallback(callback);
}

Stream<void Function()> asyncGeneratorReturn(Callable callback) async* {
  yield callback;
}