prefer-int-literals

const double myDouble = 8.0;
double? maybe = 1.0;

class Box {
  final double width = 2.0;
  Box(double size);
  Box.named({required double size});
  double get area => 3.0;
  double scale() {
    return 4.0;
  }
  double operator +(Box other) => 5.0;
}

void takesDouble(double value, {double named = 0}) {}

double negative() => -6.0;

void main() {
  double local = 7.0;
  var list = <double>[1.0, 2.5];
  takesDouble(9.0);
  takesDouble(1, named: 10.0);
  Box(11.0);
  Box.named(size: 12.0);
  double inner() {
    return 1e3;
  }
  for (double i = 0.0; i < 1; i++) {}
  print([local, list, inner]);
}

// Field formals resolve even when their fields follow a named constructor.
class Insets {
  const Insets.fromSTEB(this.start, this.top, this.end, this.bottom);
  final double start, top, end, bottom;
}

class Matrix {
  void setEntry(int row, int column, double value) {}
}

void constructorAndCascadeArguments(Matrix matrix) {
  const Insets.fromSTEB(12.0, 4.0, 12.0, 4.0);
  matrix
    ..setEntry(3, 2, -1.0)
    ..setEntry(0, 0, 2.0);
}

// Super/redirect initializer arguments use the same resolved contexts as calls.
class NumericBase {
  final double pressure, elevation;
  const NumericBase({required this.pressure, this.elevation = 0});
  const NumericBase.named(this.pressure, {this.elevation = 0});
}

class NumericChild extends NumericBase {
  const NumericChild() : super(pressure: 0.0, elevation: 8.0);
  const NumericChild.named() : super.named(-2.0, elevation: 4.0);
  const NumericChild.value(double value) : super(pressure: value);
  const NumericChild.redirect() : this.value(9.0);
}

class GenericNumericBase<T> {
  final T value;
  const GenericNumericBase(this.value);
  const GenericNumericBase.named({required this.value});
}

class GenericNumericChild extends GenericNumericBase<double> {
  const GenericNumericChild() : super(5.0);
  const GenericNumericChild.named() : super.named(value: 6.0);
}

class InitializedNumericChild extends NumericBase {
  final int marker;
  const InitializedNumericChild() : marker = 0, super(pressure: 10.0);
}

// Generic function-valued getters infer the result of callback tear-offs.
class Stub<T> {
  void thenReturn(T value) {}
}

Stub<T> Function<T>(T Function()) get when => throw 0;

class RandomValue {
  double nextDouble() => 0;
}

void genericGetterInvocation(RandomValue random) {
  when(random.nextDouble).thenReturn(0.0);
  when(random.nextDouble).thenReturn(1.0);
}