// 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.

// @dart = 2.9

import "package:expect/expect.dart";

abstract class A<T> {
  // This is ok because type inference will ensure that in C, A and M are
  // instantiated with the same T.
  T f(T x) => x; //# 01: ok
}

class B {}

mixin M1<T> on A<T> {
  T f(T x) => x;
  T g(T x) => x;
  Type h() => T;
}

class M2<T> {
  T g(T x) => x;
  Type h() => T;
}

// Inferred as `class C extends A<B> with M1<B>`
class C extends A<B> with M1 {}

// Inferred as `class D = A<B> with M1<B>`
class D = A<B> with M1;

// Inferred as `class E extends Object with M2<dynamic>`
class E extends Object with M2 {}

// Ok because a type parameter is supplied
class F extends Object with M2<B> {}

main() {
  C c = new C();
  D d = new D();
  E e = new E();
  F f = new F();

  // M1 is instantiated with B, so C.g has type (B) -> B.
  B Function(B) x = c.g; //# 02: ok
  B Function(B) x = d.g; //# 03: ok
  Null Function(Null) x = c.g; //# 04: compile-time error
  Null Function(Null) x = d.g; //# 05: compile-time error
  Object Function(Object) x = c.g; //# 06: compile-time error
  Object Function(Object) x = d.g; //# 07: compile-time error

  // And verify that the runtime system has the right type for the type
  // parameter
  Expect.equals(c.h(), B); //# 08: ok
  Expect.equals(c.h(), B); //# 09: ok

  // M2 is instantiated with dynamic, so E.g has type (dynamic) -> dynamic.
  dynamic Function(dynamic) x = e.g; //# 10: ok
  B Function(B) x = e.g; //# 11: compile-time error

  // And verify that the runtime system has the right type for the type
  // parameter
  Expect.equals(e.h(), dynamic); //# 12: ok

  // M2 is instantiated with B, so F.g has type (B) -> B.
  B Function(B) x = f.g; //# 13: ok
  Null Function(Null) x = f.g; //# 14: compile-time error
  Object Function(Object) x = f.g; //# 15: compile-time error

  // And verify that the runtime system has the right type for the type
  // parameter
  Expect.equals(f.h(), B); //# 16: ok
}