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

import "package:expect/expect.dart";

import "implicit_new_or_const_generic_test.dart" as prefix;

// Test that const constructors with const arguments become const,
// and non-const constructors or const-constructors with non-const arguments
// do not (except in a const context, which is tested elsewhere).

// This test uses a generic class, which requires new syntax.

main() {
  // Various valid object creation expressions.
  var x = 42;  // non constant variable.

  // Various valid object creation expressions of a generic constructor.
  // (Requires inference to infer `<int>` for the invocations of `D`.)
  var instances = <Object>[
    new D(x),
    new D(42),
    const D(42),
    D(x),
    D(42),

    new D.named(x),
    new D.named(42),
    const D.named(42),
    D.named(x),
    D.named(42),

    new prefix.D(x),
    new prefix.D(42),
    const prefix.D(42),
    prefix.D(x),
    prefix.D(42),

    new prefix.D.named(x),
    new prefix.D.named(42),
    const prefix.D.named(42),
    prefix.D.named(x),
    prefix.D.named(42),

    new D<int>(x),
    new D<int>(42),
    const D<int>(42),
    D<int>(x),
    D<int>(42),

    new D<int>.named(x),
    new D<int>.named(42),
    const D<int>.named(42),
    D<int>.named(x),
    D<int>.named(42),

    new prefix.D<int>(x),
    new prefix.D<int>(42),
    const prefix.D<int>(42),
    prefix.D<int>(x),
    prefix.D<int>(42),

    new prefix.D<int>.named(x),
    new prefix.D<int>.named(42),
    const prefix.D<int>.named(42),
    prefix.D<int>.named(x),
    prefix.D<int>.named(42),
  ];

  const d42 = const D<int>(42);
  for (var i = 0; i < instances.length; i++) {
    var d = instances[i];
    Expect.equals(d42, d);
    if (i % 5 == 2 || i % 5 == 4) {
      // The cases of D(42) without "new" are all constant.
      Expect.identical(d42, d, "$i");
    } else {
      // The rest are not.
      Expect.notIdentical(d42, d, "$i");
    }
  }

  // Test instance creation with type parameters.
  new G<int>().testWithInt();
}

class D<T> {
  final T x;

  const D(this.x);
  const D.named(this.x);

  int get hashCode => x.hashCode;
  bool operator==(Object other) => other is D<Object> && x == other.x;
}

class G<T> {
  // Tests creation of D<T> where T is a type variable.
  void testWithInt() {
    // Cannot create constants referencing T or x.
    var instances = [
      new D<T>(null),
      D<T>(null),

      new D<T>.named(null),
      D<T>.named(null),

      new prefix.D<T>(null),
      prefix.D<T>(null),

      new prefix.D<T>.named(null),
      prefix.D<T>.named(null),
    ];

    const dx = const D<int>(null);
    Expect.allDistinct([dx]..addAll(instances));
    for (var i = 0; i < instances.length; i++) {
      var d = instances[i];
      Expect.isTrue(d is D<T>);
      Expect.isTrue(d is! D<Null>);
      Expect.equals(dx, d, "$i");
    }
  }
}