prefer-const-constructors

class Point {
  const Point(this.x, this.y);
  const Point.origin()
      : x = 0,
        y = 0;

  final int x;
  final int y;
}

class Label {
  const Label(this.text, {this.point = const Point.origin()});

  final String text;
  final Point point;
}

class Box<T> {
  const Box(this.value);

  final T value;
}

const int limit = 10;

void use(Object value) {}

void constructors() {
  final a = Point(1, 2);
  final b = Point.origin();
  final c = new Point(3, 4);
  final d = new Point.origin();
  final e = Box<int>(limit);
  final f = Label('title', point: const Point(0, 1));
  use(Point(limit, -1));
  final List<Point> points = [Point(5, 6)];
  final Point g = .origin();
  print([a, b, c, d, e, f, points, g]);
}

enum Shade { dark, light }

class Swatch {
  const Swatch(this.value, {this.shade});
  const Swatch.named(this.value) : shade = null;
  const factory Swatch.redirect(Object? value) = Swatch;
  static const int base = 1;
  final Object? value;
  final Shade? shade;
}

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

int top() => 0;

void evaluatedArguments() {
  const local = 2;
  print(Swatch(Shade.dark));
  print(Swatch(Swatch.base));
  print(Swatch(local));
  print(Generic<int>.named(1));
  print(Swatch.redirect(1));
  print(Swatch('a' 'b'));
  print(Swatch(#symbol));
  print(Swatch(int));
  print(Swatch(top));
  print(Swatch(Swatch.named));
  print(Swatch(Shade.values));
  print(Swatch(identical(1, 2)));
  print(Swatch([if (true) 1]));
  print(Swatch({Swatch(1): 1}));
  final generic = Generic(1);
  print(generic);
}

// The context type `Box<List<T>>` has no type parameter as a type argument
// of `Box` itself, so making it `const` changes nothing.
Box<List<T>> emptyBox<T>() => Box([]);