dart-sdk/tests/dartdevc/subtype_test.dart

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

// Requirements=nnbd-strong

import 'dart:_foreign_helper' show LEGACY_TYPE_REF, TYPE_REF;
import 'dart:async' show FutureOr;

import 'runtime_utils.dart'
    show
        checkSubtype,
        checkProperSubtype,
        checkMutualSubtype,
        checkSubtypeFailure;

class A {}

class B extends A {}

class C extends B {}

class D<T extends B> {}

class E<T, S> {}

class F extends E<B, B> {}

void main() {
  // Top type symmetry.
  // Object? <:> dynamic
  checkMutualSubtype(TYPE_REF<Object?>(), TYPE_REF<dynamic>());
  // Object? <:> void
  checkMutualSubtype(TYPE_REF<Object?>(), TYPE_REF<void>());
  // void <:> dynamic
  checkMutualSubtype(TYPE_REF<void>(), TYPE_REF<dynamic>());

  // Bottom is subtype of top.
  // Never <: dynamic
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<dynamic>());
  // Never <: void
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<void>());
  // Never <: Object?
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<Object?>());

  // Object is between top and bottom.
  // Object <: Object?
  checkSubtype(TYPE_REF<Object>(), TYPE_REF<Object?>());
  // Never <: Object
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<Object>());

  // Null is between top and bottom.
  // Null <: Object?
  checkProperSubtype(TYPE_REF<Null>(), TYPE_REF<Object?>());
  // Never <: Null
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<Null>());

  // Class is between Object and bottom.
  // A <: Object
  checkProperSubtype(TYPE_REF<A>(), TYPE_REF<dynamic>());
  // Never <: A
  checkProperSubtype(TYPE_REF<Never>(), TYPE_REF<A>());

  // Nullable types are a union of T and Null.
  // A <: A?
  checkProperSubtype(TYPE_REF<A>(), TYPE_REF<A?>());
  // Null <: A?
  checkProperSubtype(TYPE_REF<Null>(), TYPE_REF<A?>());
  // A? <: Object?
  checkProperSubtype(TYPE_REF<A?>(), TYPE_REF<Object?>());

  // Legacy types will eventually be migrated to T or T? but until then are
  // symmetric with both.
  // Object* <:> Object
  checkMutualSubtype(LEGACY_TYPE_REF<Object>(), TYPE_REF<Object>());
  // Object* <:> Object?
  checkMutualSubtype(LEGACY_TYPE_REF<Object>(), TYPE_REF<Object?>());

  // Bottom Types
  // Null <: Object*
  checkSubtype(TYPE_REF<Null>(), LEGACY_TYPE_REF<Object>());
  // Never <: Object*
  checkSubtype(TYPE_REF<Never>(), LEGACY_TYPE_REF<Object>());
  // A* <:> A
  checkMutualSubtype(LEGACY_TYPE_REF<A>(), TYPE_REF<A>());
  // A* <:> A?
  checkMutualSubtype(LEGACY_TYPE_REF<A>(), TYPE_REF<A?>());
  // A* <: Object
  checkProperSubtype(LEGACY_TYPE_REF<A>(), TYPE_REF<Object>());
  // A* <: Object?
  checkProperSubtype(LEGACY_TYPE_REF<A>(), TYPE_REF<Object?>());
  // Null <: A*
  checkProperSubtype(TYPE_REF<Null>(), LEGACY_TYPE_REF<A>());
  // Never <: A*
  checkProperSubtype(TYPE_REF<Never>(), LEGACY_TYPE_REF<A>());

  // Futures.
  // Null <: FutureOr<Object?>
  checkProperSubtype(TYPE_REF<Null>(), TYPE_REF<FutureOr<Object?>>());
  // Object <: FutureOr<Object?>
  checkProperSubtype(TYPE_REF<Object>(), TYPE_REF<FutureOr<Object?>>());
  // Object? <:> FutureOr<Object?>
  checkMutualSubtype(TYPE_REF<Object?>(), TYPE_REF<FutureOr<Object?>>());
  // Object <:> FutureOr<Object>
  checkMutualSubtype(TYPE_REF<Object>(), TYPE_REF<FutureOr<Object>>());
  // Object <: FutureOr<dynamic>
  checkProperSubtype(TYPE_REF<Object>(), TYPE_REF<FutureOr<dynamic>>());
  // Object <: FutureOr<void>
  checkProperSubtype(TYPE_REF<Object>(), TYPE_REF<FutureOr<void>>());
  // Future<Object> <: FutureOr<Object?>
  checkProperSubtype(TYPE_REF<Future<Object>>(), TYPE_REF<FutureOr<Object?>>());
  // Future<Object?> <: FutureOr<Object?>
  checkProperSubtype(
      TYPE_REF<Future<Object?>>(), TYPE_REF<FutureOr<Object?>>());
  // FutureOr<Never> <: Future<Never>
  checkSubtype(TYPE_REF<FutureOr<Never>>(), TYPE_REF<Future<Never>>());
  // Future<B> <: FutureOr<A>
  checkProperSubtype(TYPE_REF<Future<B>>(), TYPE_REF<FutureOr<A>>());
  // B <: <: FutureOr<A>
  checkProperSubtype(TYPE_REF<B>(), TYPE_REF<FutureOr<A>>());
  // Future<B> <: Future<A>
  checkProperSubtype(TYPE_REF<Future<B>>(), TYPE_REF<Future<A>>());

  // Interface subtypes.
  // A <: A
  checkSubtype(TYPE_REF<A>(), TYPE_REF<A>());
  // B <: A
  checkProperSubtype(TYPE_REF<B>(), TYPE_REF<A>());
  // C <: B
  checkProperSubtype(TYPE_REF<C>(), TYPE_REF<B>());
  // C <: A
  checkProperSubtype(TYPE_REF<C>(), TYPE_REF<A>());

  // Functions.
  // A -> B <: Function
  checkProperSubtype(TYPE_REF<B Function(A)>(), TYPE_REF<Function>());

  // A -> B <: A -> B
  checkSubtype(TYPE_REF<B Function(A)>(), TYPE_REF<B Function(A)>());

  // A -> B <: B -> B
  checkProperSubtype(TYPE_REF<B Function(A)>(), TYPE_REF<B Function(B)>());

  // A -> B <: A -> A
  checkProperSubtype(TYPE_REF<B Function(A)>(), TYPE_REF<A Function(A)>());

  // Generic Function Subtypes.
  // Bound is a built in type.
  // <T extends int> void -> void <: <T extends int> void -> void
  checkSubtype(TYPE_REF<void Function<T extends int>()>(),
      TYPE_REF<void Function<T extends int>()>());

  // <T extends String> A -> T <: <T extends String> B -> T
  checkProperSubtype(TYPE_REF<T Function<T extends String>(A)>(),
      TYPE_REF<T Function<T extends String>(B)>());

  // <T extends double> T -> B <: <T extends double> T -> A
  checkProperSubtype(TYPE_REF<B Function<T extends double>(T)>(),
      TYPE_REF<A Function<T extends double>(T)>());

  // Bound is a function type.
  // <T extends A -> B> void -> void <: <T extends A -> B> void -> void
  checkSubtype(TYPE_REF<void Function<T extends A Function(B)>()>(),
      TYPE_REF<void Function<T extends A Function(B)>()>());

  // <T extends A -> B> A -> T <: <T extends A -> B> B -> T
  checkProperSubtype(TYPE_REF<T Function<T extends A Function(B)>(A)>(),
      TYPE_REF<T Function<T extends A Function(B)>(B)>());

  // <T extends A -> B> T -> B <: <T extends A -> B> T -> A
  checkProperSubtype(TYPE_REF<B Function<T extends A Function(B)>(T)>(),
      TYPE_REF<A Function<T extends A Function(B)>(T)>());

  // Bound is a user defined class.
  // <T extends B> void -> void <: <T extends B> void -> void
  checkSubtype(TYPE_REF<void Function<T extends B>()>(),
      TYPE_REF<void Function<T extends B>()>());

  // <T extends B> A -> T <: <T extends B> B -> T
  checkProperSubtype(TYPE_REF<T Function<T extends B>(A)>(),
      TYPE_REF<T Function<T extends B>(B)>());

  // // <T extends B> T -> B <: <T extends B> T -> A
  checkProperSubtype(TYPE_REF<B Function<T extends B>(T)>(),
      TYPE_REF<A Function<T extends B>(T)>());

  // Bound is a Future.
  // <T extends Future<B>> void -> void <: <T extends Future<B>> void -> void
  checkSubtype(TYPE_REF<void Function<T extends Future<B>>()>(),
      TYPE_REF<void Function<T extends Future<B>>()>());

  // <T extends Future<B>> A -> T <: <T extends Future<B>> B -> T
  checkProperSubtype(TYPE_REF<T Function<T extends Future<B>>(A)>(),
      TYPE_REF<T Function<T extends Future<B>>(B)>());

  // <T extends Future<B>> T -> B <: <T extends Future<B>> T -> A
  checkProperSubtype(TYPE_REF<B Function<T extends Future<B>>(T)>(),
      TYPE_REF<A Function<T extends Future<B>>(T)>());

  // Bound is a FutureOr.
  // <T extends FutureOr<B>> void -> void <:
  //    <T extends FutureOr<B>> void -> void
  checkSubtype(TYPE_REF<void Function<T extends FutureOr<B>>()>(),
      TYPE_REF<void Function<T extends FutureOr<B>>()>());

  // <T extends FutureOr<B>> A -> T <: <T extends FutureOr<B>> B -> T
  checkProperSubtype(TYPE_REF<T Function<T extends FutureOr<B>>(A)>(),
      TYPE_REF<T Function<T extends FutureOr<B>>(B)>());

  // <T extends FutureOr<B>> T -> B <: <T extends FutureOr<B>> T -> A
  checkProperSubtype(TYPE_REF<B Function<T extends FutureOr<B>>(T)>(),
      TYPE_REF<A Function<T extends FutureOr<B>>(T)>());

  // Generics.
  // D <:> D<B>
  checkMutualSubtype(TYPE_REF<D>(), TYPE_REF<D<B>>());
  // D<C> <: D<B>
  checkProperSubtype(TYPE_REF<D<C>>(), TYPE_REF<D<B>>());

  // F <: E
  checkProperSubtype(TYPE_REF<F>(), TYPE_REF<E>());
  // F <: E<A, A>
  checkProperSubtype(TYPE_REF<F>(), TYPE_REF<E<A, A>>());
  // E<B, B> <: E
  checkProperSubtype(TYPE_REF<E<B, B>>(), TYPE_REF<E>());
  // E<B, B> <: E<A, A>
  checkProperSubtype(TYPE_REF<E<B, B>>(), TYPE_REF<E<A, A>>());

  // Nullable interface subtypes.
  // B <: A?
  checkProperSubtype(TYPE_REF<B>(), TYPE_REF<A?>());
  // C <: A?
  checkProperSubtype(TYPE_REF<C>(), TYPE_REF<A?>());
  // B? <: A?
  checkProperSubtype(TYPE_REF<B?>(), TYPE_REF<A?>());
  // C? <: A?
  checkProperSubtype(TYPE_REF<C?>(), TYPE_REF<A?>());

  // Mixed mode.
  // B* <: A
  checkProperSubtype(LEGACY_TYPE_REF<B>(), TYPE_REF<A>());
  // B* <: A?
  checkProperSubtype(LEGACY_TYPE_REF<B>(), TYPE_REF<A?>());
  // A* <\: B
  checkSubtypeFailure(LEGACY_TYPE_REF<A>(), TYPE_REF<B>());
  // B? <: A*
  checkProperSubtype(TYPE_REF<B?>(), LEGACY_TYPE_REF<A>());
  // B <: A*
  checkProperSubtype(TYPE_REF<B>(), LEGACY_TYPE_REF<A>());
  // A <: B*
  checkSubtypeFailure(TYPE_REF<A>(), LEGACY_TYPE_REF<B>());
  // A? <: B*
  checkSubtypeFailure(TYPE_REF<A?>(), LEGACY_TYPE_REF<B>());

  // Allowed in weak mode.
  // dynamic <\: Object
  checkSubtypeFailure(TYPE_REF<dynamic>(), TYPE_REF<Object>());
  // void <\: Object
  checkSubtypeFailure(TYPE_REF<void>(), TYPE_REF<Object>());
  // Object? <\: Object
  checkSubtypeFailure(TYPE_REF<Object?>(), TYPE_REF<Object>());
  // A? <\: Object
  checkSubtypeFailure(TYPE_REF<A?>(), TYPE_REF<Object>());
  // A? <\: A
  checkSubtypeFailure(TYPE_REF<A?>(), TYPE_REF<A>());
  // Null <\: Never
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<Never>());
  // Null <\: Object
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<Object>());
  // Null <\: A
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<A>());
  // Null <\: FutureOr<A>
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<FutureOr<A>>());
  // Null <\: Future<A>
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<Future<A>>());
  // FutureOr<Null> <\: Future<Null>
  checkSubtypeFailure(TYPE_REF<FutureOr<Null>>(), TYPE_REF<Future<Null>>());
  // Null <\: Future<A?>
  checkSubtypeFailure(TYPE_REF<Null>(), TYPE_REF<Future<A?>>());
  // FutureOr<Object?> <\: Object
  checkSubtypeFailure(TYPE_REF<FutureOr<Object?>>(), TYPE_REF<Object>());
  // FutureOr<dynamic> <\: Object
  checkSubtypeFailure(TYPE_REF<FutureOr<dynamic>>(), TYPE_REF<Object>());
  // FutureOr<void> <\: Object
  checkSubtypeFailure(TYPE_REF<FutureOr<void>>(), TYPE_REF<Object>());
}