// Copyright (c) 2019, 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:front_end/src/fasta/type_inference/type_schema.dart';
import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/core_types.dart';
import 'package:kernel/class_hierarchy.dart';
import 'package:kernel/testing/type_parser_environment.dart';
import 'package:kernel/testing/mock_sdk.dart';
import 'package:kernel/type_environment.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(TypeSchemaEnvironmentTest);
  });
}

@reflectiveTest
class TypeSchemaEnvironmentTest {
  Component component;

  CoreTypes coreTypes;

  TypeSchemaEnvironment env;

  TypeParserEnvironment typeParserEnvironment;

  Library get testLib => component.libraries.single;

  Class get iterableClass => coreTypes.iterableClass;

  Class get listClass => coreTypes.listClass;

  Class get mapClass => coreTypes.mapClass;

  Class get objectClass => coreTypes.objectClass;

  DartType get bottomType => const NeverType(Nullability.nonNullable);

  DartType get topType => coreTypes.objectNullableRawType;

  /// Converts the [text] representation of a type into a type.
  ///
  /// If [environment] is passed it's used to resolve the type terms in [text].
  /// If [typeParameters] are passed, they are used to extend
  /// [typeParserEnvironment] to resolve the type terms in [text].  Not more
  /// than one of [environment] or [typeParameters] should be passed in.
  DartType toType(String text,
      {TypeParserEnvironment environment, String typeParameters}) {
    assert(environment == null || typeParameters == null);
    environment ??= extend(typeParameters);
    return environment.parseType(text);
  }

  TypeParserEnvironment extend(String typeParameters) {
    return typeParserEnvironment.extendWithTypeParameters(typeParameters);
  }

  void test_addLowerBound() {
    const String testSdk = """
      class A;
      class B extends A;
      class C extends A;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.
    TypeConstraint typeConstraint = new TypeConstraint();

    // typeConstraint: EMPTY <: TYPE <: EMPTY
    expect(typeConstraint.lower, new UnknownType());

    // typeConstraint: B* <: TYPE <: EMPTY
    env.addLowerBound(typeConstraint, toType("B*"), testLib);
    testConstraint(typeConstraint, lowerExpected: toType("B*"));

    // typeConstraint: UP(B*, C*) <: TYPE <: EMPTY,
    //     where UP(B*, C*) = A*
    env.addLowerBound(typeConstraint, toType("C*"), testLib);
    testConstraint(typeConstraint, lowerExpected: toType("A*"));
  }

  void test_addUpperBound() {
    const String testSdk = """
      class A;
      class B extends A;
      class C extends A;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.
    TypeConstraint typeConstraint = new TypeConstraint();

    // typeConstraint: EMPTY <: TYPE <: EMPTY
    expect(typeConstraint.upper, new UnknownType());

    // typeConstraint: EMPTY <: TYPE <: A*
    env.addUpperBound(typeConstraint, toType("A*"), testLib);
    testConstraint(typeConstraint, upperExpected: toType("A*"));

    // typeConstraint: EMPTY <: TYPE <: DOWN(A*, B*),
    //     where DOWN(A*, B*) = B*
    env.addUpperBound(typeConstraint, toType("B*"), testLib);
    testConstraint(typeConstraint, upperExpected: toType("B*"));

    // typeConstraint: EMPTY <: TYPE <: DOWN(B*, C*),
    //     where DOWN(B*, C*) = Never*
    env.addUpperBound(typeConstraint, toType("C*"), testLib);
    testConstraint(typeConstraint,
        upperExpected: new NeverType(Nullability.legacy));
  }

  /// Some of the types satisfying the TOP predicate.
  ///
  /// There's an infinite amount of such types, and the list contains some
  /// practical base cases.  For the definition of TOP see the following:
  /// https://github.com/dart-lang/language/blob/master/resources/type-system/upper-lower-bounds.md#helper-predicates
  static const Map<String, String> topPredicateEnumeration = <String, String>{
    // dynamic and void.
    "dynamic": null,
    "void": null,

    // T? where OBJECT(T).
    "Object?": null,
    "FutureOr<Object>?": null,
    "FutureOr<FutureOr<Object>>?": null,

    // T* where OBJECT(t).
    "Object*": null,
    "FutureOr<Object>*": null,
    "FutureOr<FutureOr<Object>>*": null,

    // FutureOr<T> where TOP(T).
    "FutureOr<dynamic>": null,
    "FutureOr<void>": null,
    "FutureOr<Object?>": null,
    "FutureOr<FutureOr<Object>?>": null,
    "FutureOr<FutureOr<FutureOr<Object>>?>": null,
    "FutureOr<Object*>": null,
    "FutureOr<FutureOr<Object>*>": null,
    "FutureOr<FutureOr<FutureOr<Object>>*>": null,
    "FutureOr<FutureOr<dynamic>?>": null,
    "FutureOr<FutureOr<void>?>": null,
    "FutureOr<FutureOr<Object?>?>": null,
    "FutureOr<FutureOr<FutureOr<Object>?>?>": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>?>": null,
    "FutureOr<FutureOr<Object*>?>": null,
    "FutureOr<FutureOr<FutureOr<Object>*>?>": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>?>": null,
    "FutureOr<FutureOr<dynamic>*>": null,
    "FutureOr<FutureOr<void>*>": null,
    "FutureOr<FutureOr<Object?>*>": null,
    "FutureOr<FutureOr<FutureOr<Object>?>*>": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>*>": null,
    "FutureOr<FutureOr<Object*>*>": null,
    "FutureOr<FutureOr<FutureOr<Object>*>*>": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>*>": null,

    // T? where TOP(T).
    "FutureOr<dynamic>?": null,
    "FutureOr<void>?": null,
    "FutureOr<Object?>?": null,
    "FutureOr<FutureOr<Object>?>?": null,
    "FutureOr<FutureOr<FutureOr<Object>>?>?": null,
    "FutureOr<Object*>?": null,
    "FutureOr<FutureOr<Object>*>?": null,
    "FutureOr<FutureOr<FutureOr<Object>>*>?": null,
    "FutureOr<FutureOr<dynamic>?>?": null,
    "FutureOr<FutureOr<void>?>?": null,
    "FutureOr<FutureOr<Object?>?>?": null,
    "FutureOr<FutureOr<FutureOr<Object>?>?>?": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>?>?": null,
    "FutureOr<FutureOr<Object*>?>?": null,
    "FutureOr<FutureOr<FutureOr<Object>*>?>?": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>?>?": null,
    "FutureOr<FutureOr<dynamic>*>?": null,
    "FutureOr<FutureOr<void>*>?": null,
    "FutureOr<FutureOr<Object?>*>?": null,
    "FutureOr<FutureOr<FutureOr<Object>?>*>?": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>*>?": null,
    "FutureOr<FutureOr<Object*>*>?": null,
    "FutureOr<FutureOr<FutureOr<Object>*>*>?": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>*>?": null,

    // T* where TOP(T).
    "FutureOr<dynamic>*": null,
    "FutureOr<void>*": null,
    "FutureOr<Object?>*": null,
    "FutureOr<FutureOr<Object>?>*": null,
    "FutureOr<FutureOr<FutureOr<Object>>?>*": null,
    "FutureOr<Object*>*": null,
    "FutureOr<FutureOr<Object>*>*": null,
    "FutureOr<FutureOr<FutureOr<Object>>*>*": null,
    "FutureOr<FutureOr<dynamic>?>*": null,
    "FutureOr<FutureOr<void>?>*": null,
    "FutureOr<FutureOr<Object?>?>*": null,
    "FutureOr<FutureOr<FutureOr<Object>?>?>*": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>?>*": null,
    "FutureOr<FutureOr<Object*>?>*": null,
    "FutureOr<FutureOr<FutureOr<Object>*>?>*": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>?>*": null,
    "FutureOr<FutureOr<dynamic>*>*": null,
    "FutureOr<FutureOr<void>*>*": null,
    "FutureOr<FutureOr<Object?>*>*": null,
    "FutureOr<FutureOr<FutureOr<Object>?>*>*": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>?>*>*": null,
    "FutureOr<FutureOr<Object*>*>*": null,
    "FutureOr<FutureOr<FutureOr<Object>*>*>*": null,
    "FutureOr<FutureOr<FutureOr<FutureOr<Object>>*>*>*": null,
  };

  /// Some of the types satisfying the OBJECT predicate.
  ///
  /// There's an infinite amount of such types, and the list contains some
  /// practical base cases.  For the definition of OBJECT see the following:
  /// https://github.com/dart-lang/language/blob/master/resources/type-system/upper-lower-bounds.md#helper-predicates
  static const Map<String, String> objectPredicateEnumeration = {
    "Object": null,
    "FutureOr<Object>": null,
    "FutureOr<FutureOr<Object>>": null,
  };

  /// Some of the types satisfying the BOTTOM predicate.
  ///
  /// There's an infinite amount of such types, and the list contains some
  /// practical base cases.  For the definition of BOTTOM see the following:
  /// https://github.com/dart-lang/language/blob/master/resources/type-system/upper-lower-bounds.md#helper-predicates
  ///
  /// The names of the variables here and in [nullPredicateEnumeration] should
  /// be distinct to avoid collisions.
  static const Map<String, String> bottomPredicateEnumeration = {
    "Never": null,
    "Xb & Never": "Xb extends Object?",
    "Yb & Zb & Never": "Yb extends Object?, Zb extends Object?",
    "Vb": "Vb extends Never",
    "Wb": "Wb extends Tb, Tb extends Never",
    "Sb & Rb": "Sb extends Object?, Rb extends Never",
  };

  /// Some of the types satisfying the NULL predicate.
  ///
  /// There's an infinite amount of such types, and the list contains some
  /// practical base cases.  For the definition of NULL see the following:
  /// https://github.com/dart-lang/language/blob/master/resources/type-system/upper-lower-bounds.md#helper-predicates
  ///
  /// The names of the variables here and in [bottomPredicateEnumeration] should
  /// be distinct to avoid collisions.
  static const Map<String, String> nullPredicateEnumeration = {
    // T? where BOTTOM(T).
    "Never?": null,
    "Xn?": "Xn extends Never",
    "Yn?": "Yn extends Zn, Zn extends Never",

    // T* where BOTTOM(T).
    "Never*": null,
    "Vn*": "Vn extends Never",
    "Wn*": "Wn extends Tn, Tn extends Never",

    // Null.
    "Null": null,
  };

  static String joinTypeParameters(
      String typeParameters1, String typeParameters2) {
    if (typeParameters1 == null) return typeParameters2;
    if (typeParameters2 == null) return typeParameters1;
    if (typeParameters1 == typeParameters2) return typeParameters1;
    return "$typeParameters1, $typeParameters2";
  }

  void testLower(String first, String second, String expected,
      {String typeParameters}) {
    TypeParserEnvironment environment = extend(typeParameters);
    DartType firstType = toType(first, environment: environment);
    DartType secondType = toType(second, environment: environment);
    DartType expectedType = toType(expected, environment: environment);
    DartType producedType =
        env.getStandardLowerBound(firstType, secondType, testLib);
    expect(producedType, expectedType,
        reason: "DOWN(${firstType}, ${secondType}) produced '${producedType}', "
            "but expected '${expectedType}'.");
  }

  void testUpper(String first, String second, String expected,
      {String typeParameters}) {
    TypeParserEnvironment environment = extend(typeParameters);
    DartType firstType = toType(first, environment: environment);
    DartType secondType = toType(second, environment: environment);
    DartType expectedType = toType(expected, environment: environment);
    DartType producedType =
        env.getStandardUpperBound(firstType, secondType, testLib);
    expect(producedType, expectedType,
        reason: "UP(${firstType}, ${secondType}) produced '${producedType}', "
            "but expected '${expectedType}'.");
  }

  void testConstraint(TypeConstraint typeConstraint,
      {DartType lowerExpected, DartType upperExpected}) {
    assert(lowerExpected != null || upperExpected != null);
    if (lowerExpected != null) {
      expect(typeConstraint.lower, lowerExpected,
          reason: "Expected the lower bound to be '${lowerExpected}' "
              "for the following type constraint: ${typeConstraint}");
    }
    if (upperExpected != null) {
      expect(typeConstraint.upper, upperExpected,
          reason: "Expected the upper bound to be '${upperExpected}' "
              "for the following type constraint: ${typeConstraint}");
    }
  }

  void test_lower_bound_bottom() {
    _initialize("class A;");

    for (String type in ["A*", "A?", "A"]) {
      testLower("bottom", type, "bottom");
      testLower(type, "bottom", "bottom");
    }

    // DOWN(T1, T2) where BOTTOM(T1) and BOTTOM(T2) =
    //   T1 if MOREBOTTOM(T1, T2)
    //   T2 otherwise
    for (String t1 in bottomPredicateEnumeration.keys) {
      for (String t2 in bottomPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            bottomPredicateEnumeration[t1], bottomPredicateEnumeration[t2]);
        String expected = env.morebottom(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t1
            : t2;
        testLower(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // DOWN(T1, T2) = T2 if BOTTOM(T2)
    for (String type in ["A*", "A?", "A"]) {
      for (String t2 in bottomPredicateEnumeration.keys) {
        testLower(type, t2, t2, typeParameters: bottomPredicateEnumeration[t2]);
      }
    }

    // DOWN(T1, T2) = T1 if BOTTOM(T1)
    for (String t1 in bottomPredicateEnumeration.keys) {
      for (String type in ["A*", "A?", "A"]) {
        testLower(t1, type, t1, typeParameters: bottomPredicateEnumeration[t1]);
      }
    }

    // DOWN(T1, T2) where NULL(T1) and NULL(T2) =
    //   T1 if MOREBOTTOM(T1, T2)
    //   T2 otherwise
    for (String t1 in nullPredicateEnumeration.keys) {
      for (String t2 in nullPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            nullPredicateEnumeration[t1], nullPredicateEnumeration[t2]);
        String expected = env.morebottom(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t1
            : t2;
        testLower(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // DOWN(Null, T2) =
    //   Null if Null <: T2
    //   Never otherwise
    for (String t1 in nullPredicateEnumeration.keys) {
      testLower(t1, "A*", t1, typeParameters: nullPredicateEnumeration[t1]);
      testLower(t1, "A?", t1, typeParameters: nullPredicateEnumeration[t1]);
      testLower(t1, "A", "Never", typeParameters: nullPredicateEnumeration[t1]);
    }

    // DOWN(T1, Null) =
    //   Null if Null <: T1
    //   Never otherwise
    for (String t2 in nullPredicateEnumeration.keys) {
      testLower("A*", t2, t2, typeParameters: nullPredicateEnumeration[t2]);
      testLower("A?", t2, t2, typeParameters: nullPredicateEnumeration[t2]);
      testLower("A", t2, "Never", typeParameters: nullPredicateEnumeration[t2]);
    }
  }

  void test_lower_bound_object() {
    _initialize("");

    testLower("Object", "FutureOr<Null>", "FutureOr<Never>");
    testLower("FutureOr<Null>", "Object", "FutureOr<Never>");

    // FutureOr<dynamic> is top.
    testLower("Object", "FutureOr<dynamic>", "Object");
    testLower("FutureOr<dynamic>", "Object", "Object");

    // FutureOr<X> is not top and cannot be made non-nullable.
    testLower("Object", "FutureOr<X>", "Never",
        typeParameters: 'X extends dynamic');
    testLower("FutureOr<X>", "Object", "Never",
        typeParameters: 'X extends dynamic');

    // FutureOr<void> is top.
    testLower("Object", "FutureOr<void>", "Object");
    testLower("FutureOr<void>", "Object", "Object");
  }

  void test_lower_bound_function() {
    const String testSdk = """
      class A;
      class B extends A;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.
    testLower("() ->* A*", "() ->* B*", "() ->* B*");
    testLower("() ->* void", "(A*, B*) ->* void", "([A*, B*]) ->* void");
    testLower("(A*, B*) ->* void", "() ->* void", "([A*, B*]) ->* void");
    testLower("(A*) ->* void", "(B*) ->* void", "(A*) ->* void");
    testLower("(B*) ->* void", "(A*) ->* void", "(A*) ->* void");
    testLower(
        "({A* a}) ->* void", "({B* b}) ->* void", "({A* a, B* b}) ->* void");
    testLower(
        "({B* b}) ->* void", "({A* a}) ->* void", "({A* a, B* b}) ->* void");
    testLower("({A* a, A* c}) ->* void", "({B* b, B* d}) ->* void",
        "({A* a, B* b, A* c, B* d}) ->* void");
    testLower("({A* a, B* b}) ->* void", "({B* a, A* b}) ->* void",
        "({A* a, A* b}) ->* void");
    testLower("({B* a, A* b}) ->* void", "({A* a, B* b}) ->* void",
        "({A* a, A* b}) ->* void");
    testLower(
        "(B*, {A* a}) ->* void", "(B*) ->* void", "(B*, {A* a}) ->* void");
    testLower("({A* a}) -> void", "(B*) -> void", "Never");
    testLower("({A* a}) -> void", "([B*]) ->* void", "Never");
    testLower("<X>() -> void", "<Y>() -> void", "<Z>() -> void");
    testLower("<X>(X) -> List<X>", "<Y>(Y) -> List<Y>", "<Z>(Z) -> List<Z>");
    testLower(
        "<X1, X2 extends List<X1>>(X1) -> X2",
        "<Y1, Y2 extends List<Y1>>(Y1) -> Y2",
        "<Z1, Z2 extends List<Z1>>(Z1) -> Z2");
    testLower(
        "<X extends int>(X) -> void", "<Y extends double>(Y) -> void", "Never");

    testLower(
        "({required A a, A b, required A c, A d, required A e}) -> A",
        "({required B a, required B b, B c, B f, required B g}) -> B",
        "({required A a, A b, A c, A d, A e, B f, B g}) -> B");

    testLower("<X extends dynamic>() -> void", "<Y extends Object?>() -> void",
        "<Z extends dynamic>() -> void");
    testLower("<X extends Null>() -> void", "<Y extends Never?>() -> void",
        "<Z extends Null>() -> void");
    testLower(
        "<X extends FutureOr<dynamic>?>() -> void",
        "<Y extends FutureOr<Object?>>() -> void",
        "<Z extends FutureOr<dynamic>?>() -> void");
  }

  void test_lower_bound_identical() {
    _initialize("class A;");

    testLower("A*", "A*", "A*");
    testLower("A?", "A?", "A?");
    testLower("A", "A", "A");
  }

  void test_lower_bound_subtype() {
    const String testSdk = """
      class A;
      class B extends A;
    """;
    _initialize(testSdk);

    testLower("A*", "B*", "B*");
    testLower("A*", "B?", "B*");
    testLower("A*", "B", "B");

    testLower("A?", "B*", "B*");
    testLower("A?", "B?", "B?");
    testLower("A?", "B", "B");

    testLower("A", "B*", "B");
    testLower("A", "B?", "B");
    testLower("A", "B", "B");

    testLower("B*", "A*", "B*");
    testLower("B?", "A*", "B*");
    testLower("B", "A*", "B");

    testLower("B*", "A?", "B*");
    testLower("B?", "A?", "B?");
    testLower("B", "A?", "B");

    testLower("B*", "A", "B");
    testLower("B?", "A", "B");
    testLower("B", "A", "B");

    testLower("Iterable<A>*", "List<B>*", "List<B>*");
    testLower("Iterable<A>*", "List<B>?", "List<B>*");
    testLower("Iterable<A>*", "List<B>", "List<B>");

    testLower("Iterable<A>?", "List<B>*", "List<B>*");
    testLower("Iterable<A>?", "List<B>?", "List<B>?");
    testLower("Iterable<A>?", "List<B>", "List<B>");

    testLower("Iterable<A>", "List<B>*", "List<B>");
    testLower("Iterable<A>", "List<B>?", "List<B>");
    testLower("Iterable<A>", "List<B>", "List<B>");

    testLower("List<B>*", "Iterable<A>*", "List<B>*");
    testLower("List<B>?", "Iterable<A>*", "List<B>*");
    testLower("List<B>", "Iterable<A>*", "List<B>");

    testLower("List<B>*", "Iterable<A>?", "List<B>*");
    testLower("List<B>?", "Iterable<A>?", "List<B>?");
    testLower("List<B>", "Iterable<A>?", "List<B>");

    testLower("List<B>*", "Iterable<A>", "List<B>");
    testLower("List<B>?", "Iterable<A>", "List<B>");
    testLower("List<B>", "Iterable<A>", "List<B>");
  }

  void test_lower_bound_top() {
    _initialize("class A;");

    // TODO(dmitryas): Test for various nullabilities.
    testLower("dynamic", "A*", "A*");
    testLower("A*", "dynamic", "A*");
    testLower("Object?", "A*", "A*");
    testLower("A*", "Object?", "A*");
    testLower("void", "A*", "A*");
    testLower("A*", "void", "A*");

    // DOWN(T1, T2) where TOP(T1) and TOP(T2) =
    //   T1 if MORETOP(T2, T1)
    //   T2 otherwise
    for (String t1 in topPredicateEnumeration.keys) {
      for (String t2 in topPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            topPredicateEnumeration[t1], topPredicateEnumeration[t2]);
        String expected = env.moretop(
                toType(t2, typeParameters: typeParameters),
                toType(t1, typeParameters: typeParameters))
            ? t1
            : t2;
        testLower(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // DOWN(T1, T2) = T2 if TOP(T1)
    for (String t1 in topPredicateEnumeration.keys) {
      testLower(t1, "A*", "A*", typeParameters: topPredicateEnumeration[t1]);
    }

    // DOWN(T1, T2) = T1 if TOP(T2)
    for (String t2 in topPredicateEnumeration.keys) {
      testLower("A*", t2, "A*", typeParameters: topPredicateEnumeration[t2]);
    }
  }

  void test_lower_bound_unknown() {
    _initialize("class A;");

    testLower("A*", "unknown", "A*");
    testLower("A?", "unknown", "A?");
    testLower("A", "unknown", "A");

    testLower("unknown", "A*", "A*");
    testLower("unknown", "A?", "A?");
    testLower("unknown", "A", "A");
  }

  void test_lower_bound_unrelated() {
    const String testSdk = """
      class A;
      class B;
    """;
    _initialize(testSdk);

    testLower("A*", "B*", "Never*");
    testLower("A*", "B?", "Never*");
    testLower("A*", "B", "Never");

    testLower("A?", "B*", "Never*");
    testLower("A?", "B?", "Never?");
    testLower("A?", "B", "Never");

    testLower("A", "B*", "Never");
    testLower("A", "B?", "Never");
    testLower("A", "B", "Never");
  }

  void test_inferGenericFunctionOrType() {
    _initialize("");

    // TODO(dmitryas): Test for various nullabilities.
    InterfaceType listClassThisType =
        coreTypes.thisInterfaceType(listClass, testLib.nonNullable);
    {
      // Test an instantiation of [1, 2.0] with no context.  This should infer
      // as List<?> during downwards inference.
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      TypeParameterType T = listClassThisType.typeArguments[0];
      env.inferGenericFunctionOrType(listClassThisType, [T.parameter], null,
          null, null, inferredTypes, testLib);
      expect(inferredTypes[0], new UnknownType());
      // And upwards inference should refine it to List<num>.
      env.inferGenericFunctionOrType(
          listClassThisType,
          [T.parameter],
          [T, T],
          [coreTypes.intNonNullableRawType, coreTypes.doubleNonNullableRawType],
          null,
          inferredTypes,
          testLib);
      expect(inferredTypes[0], coreTypes.numNonNullableRawType);
    }
    {
      // Test an instantiation of [1, 2.0] with a context of List<Object>.  This
      // should infer as List<Object> during downwards inference.
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      TypeParameterType T = listClassThisType.typeArguments[0];
      env.inferGenericFunctionOrType(
          listClassThisType,
          [T.parameter],
          null,
          null,
          _list(coreTypes.objectNonNullableRawType),
          inferredTypes,
          testLib);
      expect(inferredTypes[0], coreTypes.objectNonNullableRawType);
      // And upwards inference should preserve the type.
      env.inferGenericFunctionOrType(
          listClassThisType,
          [T.parameter],
          [T, T],
          [coreTypes.intNonNullableRawType, coreTypes.doubleNonNullableRawType],
          _list(coreTypes.objectNonNullableRawType),
          inferredTypes,
          testLib);
      expect(inferredTypes[0], coreTypes.objectNonNullableRawType);
    }
    {
      // Test an instantiation of [1, 2.0, null] with no context.  This should
      // infer as List<?> during downwards inference.
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      TypeParameterType T = listClassThisType.typeArguments[0];
      env.inferGenericFunctionOrType(listClassThisType, [T.parameter], null,
          null, null, inferredTypes, testLib);
      expect(inferredTypes[0], new UnknownType());
      // And upwards inference should refine it to List<num?>.
      env.inferGenericFunctionOrType(
          listClassThisType,
          [T.parameter],
          [T, T, T],
          [
            coreTypes.intNonNullableRawType,
            coreTypes.doubleNonNullableRawType,
            const NullType()
          ],
          null,
          inferredTypes,
          testLib);
      expect(inferredTypes[0], coreTypes.numNullableRawType);
    }
    {
      // Test an instantiation of legacy [1, 2.0] with no context.
      // This should infer as List<?> during downwards inference.
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      TypeParameterType T = listClassThisType.typeArguments[0];
      env.inferGenericFunctionOrType(listClassThisType, [T.parameter], null,
          null, null, inferredTypes, testLib);
      expect(inferredTypes[0], new UnknownType());
      // And upwards inference should refine it to List<num!>.
      env.inferGenericFunctionOrType(
          listClassThisType,
          [T.parameter],
          [T, T],
          [coreTypes.intLegacyRawType, coreTypes.doubleLegacyRawType],
          null,
          inferredTypes,
          testLib);
      expect(inferredTypes[0], coreTypes.numLegacyRawType);
    }
  }

  void test_inferTypeFromConstraints_applyBound() {
    _initialize("");

    // class A<T extends num*> {}
    TypeParameter T = new TypeParameter("T", coreTypes.numLegacyRawType);

    // TODO(dmitryas): Test for various nullabilities.
    {
      // With no constraints:
      Map<TypeParameter, TypeConstraint> constraints = {
        T: new TypeConstraint()
      };

      // Downward inference should infer A<?>
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib,
          downwardsInferPhase: true);
      expect(inferredTypes[0], new UnknownType());

      // Upward inference should infer A<num*>
      env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib);
      expect(inferredTypes[0], coreTypes.numLegacyRawType);
    }
    {
      // With an upper bound of Object*:
      Map<TypeParameter, TypeConstraint> constraints = {
        T: _makeConstraint(upper: coreTypes.objectLegacyRawType)
      };

      // Downward inference should infer A<num*>
      List<DartType> inferredTypes = <DartType>[new UnknownType()];
      env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib,
          downwardsInferPhase: true);
      expect(inferredTypes[0], coreTypes.numLegacyRawType);

      // Upward inference should infer A<num*>
      env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib);
      expect(inferredTypes[0], coreTypes.numLegacyRawType);

      // Upward inference should still infer A<num*> even if there are more
      // constraints now, because num was finalized during downward inference.
      constraints = {
        T: _makeConstraint(
            lower: coreTypes.intLegacyRawType,
            upper: coreTypes.intLegacyRawType)
      };
      env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib);
      expect(inferredTypes[0], coreTypes.numLegacyRawType);
    }
  }

  void test_inferTypeFromConstraints_simple() {
    _initialize("");

    TypeParameter T = listClass.typeParameters[0];

    // TODO(dmitryas): Test for various nullabilities.

    // With an upper bound of List<?>*:
    Map<TypeParameter, TypeConstraint> constraints = {
      T: _makeConstraint(upper: _list(new UnknownType()))
    };

    // Downwards inference should infer List<List<?>*>*
    List<DartType> inferredTypes = <DartType>[new UnknownType()];
    env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib,
        downwardsInferPhase: true);
    expect(inferredTypes[0], _list(new UnknownType()));

    // Upwards inference should refine that to List<List<dynamic>*>*
    env.inferTypeFromConstraints(constraints, [T], inferredTypes, testLib);
    expect(inferredTypes[0],
        _list(new InterfaceType(objectClass, Nullability.nullable)));
  }

  void test_upper_bound_classic() {
    // Make the class hierarchy:
    //
    // Object
    //   |
    //   A
    //  /|\
    // B C K
    // |X| |
    // D E L
    const String testSdk = """
      class A;
      class B implements A;
      class C implements A;
      class K implements A;
      class D implements B, C;
      class E implements B, C;
      class L implements K;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.
    testUpper("B*", "E*", "B*");
    testUpper("D*", "C*", "C*");
    testUpper("D*", "E*", "A*");
    testUpper("D*", "A*", "A*");
    testUpper("B*", "K*", "A*");
    testUpper("B*", "L*", "A*");
  }

  void test_upper_bound_commonClass() {
    _initialize("");

    testUpper("List<int*>", "List<double*>", "List<num*>");
    testUpper("List<int?>", "List<double>", "List<num?>");
  }

  void test_upper_bound_object() {
    _initialize("");

    testUpper("Object", "FutureOr<Function?>", "Object?");
    testUpper("FutureOr<Function?>", "Object", "Object?");
  }

  void test_upper_bound_function() {
    const String testSdk = """
      class A;
      class B extends A;
    """;
    _initialize(testSdk);

    testUpper("() ->? A", "() -> B?", "() ->? A?");
    testUpper("([A*]) ->* void", "(A*) ->* void", "Function*");
    testUpper("() ->* void", "(A*, B*) ->* void", "Function*");
    testUpper("(A*, B*) ->* void", "() ->* void", "Function*");
    testUpper("(A*) ->* void", "(B*) ->* void", "(B*) ->* void");
    testUpper("(B*) ->* void", "(A*) ->* void", "(B*) ->* void");
    testUpper("({A* a}) ->* void", "({B* b}) ->* void", "() ->* void");
    testUpper("({B* b}) ->* void", "({A* a}) ->* void", "() ->* void");
    testUpper(
        "({A* a, A* c}) ->* void", "({B* b, B* d}) ->* void", "() ->* void");
    testUpper("({A* a, B* b}) ->* void", "({B* a, A* b}) ->* void",
        "({B* a, B* b}) ->* void");
    testUpper("({B* a, A* b}) ->* void", "({A* a, B* b}) ->* void",
        "({B* a, B* b}) ->* void");
    testUpper("(B*, {A* a}) ->* void", "(B*) ->* void", "(B*) ->* void");
    testUpper("({A* a}) ->* void", "(B*) ->* void", "Function*");
    testUpper("() ->* void", "([B*]) ->* void", "() ->* void");
    testUpper("<X>() -> void", "<Y>() -> void", "<Z>() -> void");
    testUpper("<X>(X) -> List<X>", "<Y>(Y) -> List<Y>", "<Z>(Z) -> List<Z>");
    testUpper(
        "<X1, X2 extends List<X1>>(X1) -> X2",
        "<Y1, Y2 extends List<Y1>>(Y1) -> Y2",
        "<Z1, Z2 extends List<Z1>>(Z1) -> Z2");
    testUpper("<X extends int>() -> void", "<Y extends double>() -> void",
        "Function");

    testUpper("({required A a, B b}) -> A", "({B a, required A b}) -> B",
        "({required B a, required B b}) -> A");

    testUpper("<X extends dynamic>() -> void", "<Y extends Object?>() -> void",
        "<Z extends dynamic>() -> void");
    testUpper("<X extends Null>() -> void", "<Y extends Never?>() -> void",
        "<Z extends Null>() -> void");
    testUpper(
        "<X extends FutureOr<dynamic>?>() -> void",
        "<Y extends FutureOr<Object?>>() -> void",
        "<Z extends FutureOr<dynamic>?>() -> void");

    testUpper("([dynamic]) -> dynamic", "([dynamic]) -> dynamic",
        "([dynamic]) -> dynamic");
  }

  void test_upper_bound_identical() {
    _initialize("class A;");

    testUpper("A*", "A*", "A*");
    testUpper("A*", "A?", "A?");
    testUpper("A*", "A", "A*");

    testUpper("A?", "A*", "A?");
    testUpper("A?", "A?", "A?");
    testUpper("A?", "A", "A?");

    testUpper("A", "A*", "A*");
    testUpper("A", "A?", "A?");
    testUpper("A", "A", "A");
  }

  void test_upper_bound_sameClass() {
    const String testSdk = """
      class A;
      class B extends A;
      class Pair<X, Y>;
    """;
    _initialize(testSdk);

    testUpper("Pair<A*, B*>", "Pair<B*, A*>", "Pair<A*, A*>");
    testUpper("Pair<A*, B*>", "Pair<B?, A>", "Pair<A?, A*>");
    testUpper("Pair<A?, B?>", "Pair<B, A>", "Pair<A?, A?>");
  }

  void test_upper_bound_subtype() {
    const String testSdk = """
      class A;
      class B extends A;
    """;
    _initialize(testSdk);

    // UP(T1, T2) = T2 if T1 <: T2
    //   Note that both types must be class types at this point
    testUpper("List<B*>", "Iterable<A*>", "Iterable<A*>");
    testUpper("List<B*>", "Iterable<A?>", "Iterable<A?>");
    testUpper("List<B*>", "Iterable<A>", "Iterable<A>");
    testUpper("List<B>*", "Iterable<A>*", "Iterable<A>*");
    testUpper("List<B>*", "Iterable<A>?", "Iterable<A>?");
    testUpper("List<B>*", "Iterable<A>", "Iterable<A>*");
    testUpper("List<B>?", "Iterable<A>*", "Iterable<A>?");
    testUpper("List<B>?", "Iterable<A>?", "Iterable<A>?");
    testUpper("List<B>?", "Iterable<A>", "Iterable<A>?");

    // UP(T1, T2) = T2 if T1 <: T2
    //   Note that both types must be class types at this point
    testUpper("List<B?>", "Iterable<A*>", "Iterable<A*>");
    testUpper("List<B?>", "Iterable<A?>", "Iterable<A?>");
    testUpper("List<B>?", "Iterable<A>*", "Iterable<A>?");
    testUpper("List<B>?", "Iterable<A>?", "Iterable<A>?");
    testUpper("List<B>?", "Iterable<A>", "Iterable<A>?");
    // UP(C0<T0, ..., Tn>, C1<S0, ..., Sk>)
    //     = least upper bound of two interfaces as in Dart 1.
    testUpper("List<B?>", "Iterable<A>", "Object");

    // UP(T1, T2) = T2 if T1 <: T2
    //   Note that both types must be class types at this point
    testUpper("List<B>", "Iterable<A*>", "Iterable<A*>");
    testUpper("List<B>", "Iterable<A?>", "Iterable<A?>");
    testUpper("List<B>", "Iterable<A>", "Iterable<A>");
    testUpper("List<B>", "Iterable<A>*", "Iterable<A>*");
    testUpper("List<B>", "Iterable<A>?", "Iterable<A>?");

    // UP(T1, T2) = T1 if T2 <: T1
    //   Note that both types must be class types at this point
    testUpper("Iterable<A*>", "List<B*>", "Iterable<A*>");
    testUpper("Iterable<A*>", "List<B?>", "Iterable<A*>");
    testUpper("Iterable<A*>", "List<B>", "Iterable<A*>");
    testUpper("Iterable<A>*", "List<B>*", "Iterable<A>*");
    testUpper("Iterable<A>*", "List<B>?", "Iterable<A>?");
    testUpper("Iterable<A>*", "List<B>", "Iterable<A>*");

    // UP(T1, T2) = T1 if T2 <: T1
    //   Note that both types must be class types at this point
    testUpper("Iterable<A?>", "List<B*>", "Iterable<A?>");
    testUpper("Iterable<A?>", "List<B?>", "Iterable<A?>");
    testUpper("Iterable<A?>", "List<B>", "Iterable<A?>");
    testUpper("Iterable<A>?", "List<B>*", "Iterable<A>?");
    testUpper("Iterable<A>?", "List<B>?", "Iterable<A>?");
    testUpper("Iterable<A>?", "List<B>", "Iterable<A>?");

    // UP(T1, T2) = T1 if T2 <: T1
    //   Note that both types must be class types at this point
    testUpper("Iterable<A>", "List<B*>", "Iterable<A>");
    testUpper("Iterable<A>", "List<B>*", "Iterable<A>*");
    // UP(C0<T0, ..., Tn>, C1<S0, ..., Sk>)
    //     = least upper bound of two interfaces as in Dart 1.
    testUpper("Iterable<A>", "List<B?>", "Object");
    // UP(T1, T2) = T1 if T2 <: T1
    //   Note that both types must be class types at this point
    testUpper("Iterable<A>", "List<B>", "Iterable<A>");
  }

  void test_upper_bound_top() {
    _initialize("class A;");

    // UP(T1, T2) where TOP(T1) and TOP(T2) =
    //   T1 if MORETOP(T1, T2)
    //   T2 otherwise
    for (String t1 in topPredicateEnumeration.keys) {
      for (String t2 in topPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            topPredicateEnumeration[t1], topPredicateEnumeration[t2]);
        String expected = env.moretop(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t1
            : t2;
        testUpper(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // UP(T1, T2) = T1 if TOP(T1)
    for (String t1 in topPredicateEnumeration.keys) {
      for (String t2 in ["A*", "A?", "A"]) {
        testUpper(t1, t2, t1, typeParameters: topPredicateEnumeration[t1]);
      }
    }

    // UP(T1, T2) = T2 if TOP(T2)
    for (String t1 in ["A*", "A?", "A"]) {
      for (String t2 in topPredicateEnumeration.keys) {
        testUpper(t1, t2, t2, typeParameters: topPredicateEnumeration[t2]);
      }
    }

    // UP(T1, T2) where OBJECT(T1) and OBJECT(T2) =
    //   T1 if MORETOP(T1, T2)
    //   T2 otherwise
    for (String t1 in objectPredicateEnumeration.keys) {
      for (String t2 in objectPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            objectPredicateEnumeration[t1], objectPredicateEnumeration[t2]);
        String expected = env.moretop(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t1
            : t2;
        testUpper(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // UP(T1, T2) where OBJECT(T1) =
    //   T1 if T2 is non-nullable
    //   T1? otherwise
    for (String t1 in objectPredicateEnumeration.keys) {
      testUpper(t1, "A*", "${t1}?",
          typeParameters: objectPredicateEnumeration[t1]);
      testUpper(t1, "A?", "${t1}?",
          typeParameters: objectPredicateEnumeration[t1]);
      testUpper(t1, "A", t1);
    }

    // UP(T1, T2) where OBJECT(T2) =
    //   T2 if T1 is non-nullable
    //   T2? otherwise
    for (String t2 in objectPredicateEnumeration.keys) {
      testUpper("A*", t2, "${t2}?");
      testUpper("A?", t2, "${t2}?");
      testUpper("A", t2, t2);
    }
  }

  void test_upper_bound_bottom() {
    _initialize("class A;");

    // UP(T1, T2) where BOTTOM(T1) and BOTTOM(T2) =
    //   T2 if MOREBOTTOM(T1, T2)
    //   T1 otherwise
    for (String t1 in bottomPredicateEnumeration.keys) {
      for (String t2 in bottomPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            bottomPredicateEnumeration[t1], bottomPredicateEnumeration[t2]);
        String expected = env.morebottom(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t2
            : t1;
        testUpper(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // UP(T1, T2) = T2 if BOTTOM(T1)
    for (String t1 in bottomPredicateEnumeration.keys) {
      for (String t2 in ["A*", "A?", "A"]) {
        testUpper(t1, t2, t2, typeParameters: bottomPredicateEnumeration[t1]);
      }
    }

    // UP(T1, T2) = T1 if BOTTOM(T2)
    for (String t1 in ["A*", "A?", "A"]) {
      for (String t2 in bottomPredicateEnumeration.keys) {
        testUpper(t1, t2, t1, typeParameters: bottomPredicateEnumeration[t2]);
      }
    }

    // UP(T1, T2) where NULL(T1) and NULL(T2) =
    //   T2 if MOREBOTTOM(T1, T2)
    //   T1 otherwise
    for (String t1 in nullPredicateEnumeration.keys) {
      for (String t2 in nullPredicateEnumeration.keys) {
        String typeParameters = joinTypeParameters(
            nullPredicateEnumeration[t1], nullPredicateEnumeration[t2]);
        String expected = env.morebottom(
                toType(t1, typeParameters: typeParameters),
                toType(t2, typeParameters: typeParameters))
            ? t2
            : t1;
        testUpper(t1, t2, expected, typeParameters: typeParameters);
      }
    }

    // UP(T1, T2) where NULL(T1) =
    //   T2 if T2 is nullable
    //   T2? otherwise
    for (String t1 in nullPredicateEnumeration.keys) {
      testUpper(t1, "A*", "A?", typeParameters: nullPredicateEnumeration[t1]);
      testUpper(t1, "A?", "A?", typeParameters: nullPredicateEnumeration[t1]);
      testUpper(t1, "A", "A?", typeParameters: nullPredicateEnumeration[t1]);
    }

    // UP(T1, T2) where NULL(T2) =
    //   T1 if T1 is nullable
    //   T1? otherwise
    for (String t2 in nullPredicateEnumeration.keys) {
      testUpper("A*", t2, "A?", typeParameters: nullPredicateEnumeration[t2]);
      testUpper("A?", t2, "A?", typeParameters: nullPredicateEnumeration[t2]);
      testUpper("A", t2, "A?", typeParameters: nullPredicateEnumeration[t2]);
    }
  }

  void test_upper_bound_typeParameter() {
    _initialize("");

    // TODO(dmitryas): Test for various nullabilities.
    testUpper("T", "T", "T", typeParameters: "T extends Object");
    testUpper("T", "List<Never>", "List<Object?>",
        typeParameters: "T extends List<T>");
    testUpper("List<Never>", "T", "List<Object?>",
        typeParameters: "T extends List<T>");
    testUpper("T", "U", "List<Object?>",
        typeParameters: "T extends List<T>, U extends List<Never>");
    testUpper("U", "T", "List<Object?>",
        typeParameters: "T extends List<T>, U extends List<Never>");
  }

  void test_upper_bound_unknown() {
    _initialize("class A;");

    testLower("A*", "unknown", "A*");
    testLower("A?", "unknown", "A?");
    testLower("A", "unknown", "A");

    testLower("unknown", "A*", "A*");
    testLower("unknown", "A?", "A?");
    testLower("unknown", "A", "A");
  }

  void test_solveTypeConstraint() {
    const String testSdk = """
      class A<X>;
      class B<Y> extends A<Y>;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.

    // Solve(? <: T <: ?) => ?
    expect(env.solveTypeConstraint(_makeConstraint(), topType, bottomType),
        new UnknownType());

    // Solve(? <: T <: ?, grounded) => dynamic
    expect(
        env.solveTypeConstraint(_makeConstraint(), topType, bottomType,
            grounded: true),
        new DynamicType());

    // Solve(A <: T <: ?) => A
    expect(
        env.solveTypeConstraint(
            _makeConstraint(lower: toType("A<dynamic>*")), topType, bottomType),
        toType("A<dynamic>*"));

    // Solve(A <: T <: ?, grounded) => A
    expect(
        env.solveTypeConstraint(
            _makeConstraint(lower: toType("A<dynamic>*")), topType, bottomType,
            grounded: true),
        toType("A<dynamic>*"));

    // Solve(A<?>* <: T <: ?) => A<?>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(lower: toType("A<unknown>*")), topType, bottomType),
        toType("A<unknown>*"));

    // Solve(A<?>* <: T <: ?, grounded) => A<Never>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(lower: toType("A<unknown>*")), topType, bottomType,
            grounded: true),
        toType("A<Never>*"));

    // Solve(? <: T <: A*) => A*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(upper: toType("A<dynamic>*")), topType, bottomType),
        toType("A<dynamic>*"));

    // Solve(? <: T <: A*, grounded) => A*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(upper: toType("A<dynamic>*")), topType, bottomType,
            grounded: true),
        toType("A<dynamic>*"));

    // Solve(? <: T <: A<?>*) => A<?>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(upper: toType("A<unknown>*")), topType, bottomType),
        toType("A<unknown>*"));

    // Solve(? <: T <: A<?>*, grounded) => A<dynamic>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(upper: toType("A<unknown>*")), topType, bottomType,
            grounded: true),
        toType("A<Object?>*"));

    // Solve(B* <: T <: A*) => B*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<dynamic>*"), upper: toType("A<dynamic>*")),
            topType,
            bottomType),
        toType("B<dynamic>*"));

    // Solve(B* <: T <: A*, grounded) => B*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<dynamic>*"), upper: toType("A<dynamic>*")),
            topType,
            bottomType,
            grounded: true),
        toType("B<dynamic>*"));

    // Solve(B<?>* <: T <: A*) => A*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<unknown>*"), upper: toType("A<dynamic>*")),
            topType,
            bottomType),
        toType("A<dynamic>*"));

    // Solve(B<?>* <: T <: A*, grounded) => A*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<unknown>*"), upper: toType("A<dynamic>*")),
            topType,
            bottomType,
            grounded: true),
        toType("A<dynamic>*"));

    // Solve(B* <: T <: A<?>*) => B*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<dynamic>*"), upper: toType("A<unknown>*")),
            topType,
            bottomType),
        toType("B<dynamic>*"));

    // Solve(B* <: T <: A<?>*, grounded) => B*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<dynamic>*"), upper: toType("A<unknown>*")),
            topType,
            bottomType,
            grounded: true),
        toType("B<dynamic>*"));

    // Solve(B<?>* <: T <: A<?>*) => B<?>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<unknown>*"), upper: toType("A<unknown>*")),
            topType,
            bottomType),
        toType("B<unknown>*"));

    // Solve(B<?>* <: T <: A<?>*, grounded) => B<Never>*
    expect(
        env.solveTypeConstraint(
            _makeConstraint(
                lower: toType("B<unknown>*"), upper: toType("A<unknown>*")),
            topType,
            bottomType,
            grounded: true),
        toType("B<Never>*"));
  }

  void test_typeConstraint_default() {
    TypeConstraint typeConstraint = new TypeConstraint();
    expect(typeConstraint.lower, new UnknownType());
    expect(typeConstraint.upper, new UnknownType());
  }

  void test_typeSatisfiesConstraint() {
    const String testSdk = """
      class A;
      class B extends A;
      class C extends B;
      class D extends C;
      class E extends D;
    """;
    _initialize(testSdk);

    // TODO(dmitryas): Test for various nullabilities.
    TypeConstraint typeConstraint =
        _makeConstraint(upper: toType("B*"), lower: toType("D*"));

    expect(env.typeSatisfiesConstraint(toType("A*"), typeConstraint), isFalse);
    expect(env.typeSatisfiesConstraint(toType("B*"), typeConstraint), isTrue);
    expect(env.typeSatisfiesConstraint(toType("C*"), typeConstraint), isTrue);
    expect(env.typeSatisfiesConstraint(toType("D*"), typeConstraint), isTrue);
    expect(env.typeSatisfiesConstraint(toType("E*"), typeConstraint), isFalse);
  }

  void test_unknown_at_bottom() {
    _initialize("class A;");

    // TODO(dmitryas): Test for various nullabilities.
    expect(
        env.isSubtypeOf(new UnknownType(), toType("A*"),
            SubtypeCheckMode.ignoringNullabilities),
        isTrue);
  }

  void test_unknown_at_top() {
    const String testSdk = """
      class A;
      class Pair<X, Y>;
    """;
    _initialize(testSdk);

    expect(
        env.isSubtypeOf(toType("A*"), new UnknownType(),
            SubtypeCheckMode.ignoringNullabilities),
        isTrue);
    expect(
        env.isSubtypeOf(
            toType("Pair<A*, Null>*"),
            toType("Pair<unknown, unknown>*"),
            SubtypeCheckMode.withNullabilities),
        isTrue);
  }

  DartType _list(DartType elementType) {
    return new InterfaceType(listClass, Nullability.nonNullable, [elementType]);
  }

  TypeConstraint _makeConstraint({DartType lower, DartType upper}) {
    lower ??= new UnknownType();
    upper ??= new UnknownType();
    return new TypeConstraint()
      ..lower = lower
      ..upper = upper;
  }

  void _initialize(String testSdk) {
    Uri uri = Uri.parse("dart:core");
    typeParserEnvironment = new TypeSchemaTypeParserEnvironment(uri);
    Library library =
        parseLibrary(uri, mockSdk + testSdk, environment: typeParserEnvironment)
          ..isNonNullableByDefault = true;
    component = new Component(libraries: <Library>[library]);
    coreTypes = new CoreTypes(component);
    env = new TypeSchemaEnvironment(
        coreTypes, new ClassHierarchy(component, coreTypes));
  }
}

class TypeSchemaTypeParserEnvironment extends TypeParserEnvironment {
  TypeSchemaTypeParserEnvironment(Uri uri) : super(uri, uri);

  DartType getPredefinedNamedType(String name) {
    if (name == "unknown") {
      // Don't return a const object to ensure we test implementations that use
      // identical.
      return new UnknownType();
    }
    return null;
  }
}