unnecessary-lambdas

void log(Object? value) {}

class Point {
  Point(this.x);
  final int x;
}

class Logger {
  void write(Object? value) {}
  static void shared(Object? value) {}
}

class Screen {
  final Logger logger = Logger();
  final List<int> values = [];

  void show(List<String> names) {
    names.forEach((name) => logger.write(name));
    names.forEach((name) => describe(name));
  }

  void describe(String name) {}
}

void main(List<String> names, List<int> numbers) {
  names.forEach((name) {
    print(name);
  });
  names.forEach((name) => log(name));
  names.forEach((name) {
    return Logger.shared(name);
  });
  final logger = Logger();
  names.forEach((name) => logger.write(name));
  final points = numbers.map((x) => Point(x));
  final sink = <int>[];
  numbers.forEach((n) => sink.add(n));
  void local(int value) {}
  numbers.forEach((n) => local(n));
  print(points);
}

class Implicit {}

class Gen<T> {
  Gen();
}

class Queue2 {
  final List<int> items = [];
  final StringBuffer buffer = StringBuffer();

  void run(void Function() f) {}
  void named({void Function()? onTap}) {}

  void calls() {
    run(() {
      items.clear();
    });
    // A member falcon does not index on a stable receiver is a method.
    run(() => buffer.clear());
    // A block body discarding the call in a `void`-returning named context.
    named(onTap: () {
      items.clear();
    });
  }
}

void constructors() {
  final implicit = () => Implicit();
  final generic = () => Gen<int>();
  final identity = () => Set<int>.identity();
  print([implicit, generic, identity]);
}

// A `final` loop variable is stable even when its name is reused elsewhere.
void loops(List<Logger> loggers, List<String> names) {
  for (final logger in loggers) {
    names.forEach((name) => logger.write(name));
  }
}

void reused(List<String> names) {
  var logger = Logger();
  logger = Logger();
  names.forEach(logger.write);
}

// A list literal's element type is the closure's context.
List<Point Function(int)> builders() => [(x) => Point(x)];

void p(int value) {}

class OptionalConstructor {
  OptionalConstructor([String value = '']);
}

// Matches StringBuffer's optional Object constructor without loading SDK sources.
class Buffer {
  Buffer([Object content = '']);
}

void functionCallAndOptionalConstructors(List<int> numbers, List<String> names) {
  numbers.forEach((value) => log.call(value));
  numbers.forEach((value) => p.call(value));
  names.map((value) => Buffer(value));
  names.map((value) => Exception(value));
  names.map((value) => OptionalConstructor(value));
  names.map((String value) => OptionalConstructor(value));
}