Implement subtyping rules for FutureOr in kernel.

pkg/kernel/lib/type_environment.dart

 // Copyright (c) 2016, 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.
 library kernel.type_environment;
 
 import 'ast.dart';
 import 'class_hierarchy.dart';
 import 'core_types.dart';
 import 'type_algebra.dart';
 
 typedef void ErrorHandler(TreeNode node, String message);
 
 class TypeEnvironment extends SubtypeTester {
   final CoreTypes coreTypes;
   final ClassHierarchy hierarchy;
   InterfaceType thisType;
 
   DartType returnType;
   DartType yieldType;
   AsyncMarker currentAsyncMarker = AsyncMarker.Sync;
 
   /// An error handler for use in debugging, or `null` if type errors should not
   /// be tolerated.  See [typeError].
   ErrorHandler errorHandler;
 
   TypeEnvironment(this.coreTypes, this.hierarchy);
 
+  @override
+  bool get strongMode => false;
+
   InterfaceType get objectType => coreTypes.objectClass.rawType;
   InterfaceType get nullType => coreTypes.nullClass.rawType;
   InterfaceType get boolType => coreTypes.boolClass.rawType;
   InterfaceType get intType => coreTypes.intClass.rawType;
   InterfaceType get numType => coreTypes.numClass.rawType;
   InterfaceType get doubleType => coreTypes.doubleClass.rawType;
   InterfaceType get stringType => coreTypes.stringClass.rawType;
   InterfaceType get symbolType => coreTypes.symbolClass.rawType;
   InterfaceType get typeType => coreTypes.typeClass.rawType;
   InterfaceType get rawFunctionType => coreTypes.functionClass.rawType;
 
   Class get intClass => coreTypes.intClass;
   Class get numClass => coreTypes.numClass;
+  Class get futureOrClass => coreTypes.futureOrClass;
 
   InterfaceType literalListType(DartType elementType) {
     return new InterfaceType(coreTypes.listClass, <DartType>[elementType]);
   }
 
   InterfaceType literalMapType(DartType key, DartType value) {
     return new InterfaceType(coreTypes.mapClass, <DartType>[key, value]);
   }
 
   InterfaceType iterableType(DartType type) {
@@ skipping 84 matching lines @@
   }
 }
 
 /// The part of [TypeEnvironment] that deals with subtype tests.
 ///
 /// This lives in a separate class so it can be tested independently of the SDK.
 abstract class SubtypeTester {
   InterfaceType get objectType;
   InterfaceType get rawFunctionType;
   ClassHierarchy get hierarchy;
+  Class get futureOrClass;
+  InterfaceType futureType(DartType type);
+  bool get strongMode;
 
   /// Determines if the given type is at the bottom of the type hierarchy.  May
   /// be overridden in subclasses.
   bool isBottom(DartType type) => type is BottomType;
 
   /// Determines if the given type is at the top of the type hierarchy.  May be
   /// overridden in subclasses.
   bool isTop(DartType type) =>
       type is DynamicType || type is VoidType || type == objectType;
 
   /// Returns true if [subtype] is a subtype of [supertype].
   bool isSubtypeOf(DartType subtype, DartType supertype) {
     subtype = subtype.unalias;
     supertype = supertype.unalias;
     if (identical(subtype, supertype)) return true;
     if (isBottom(subtype)) return true;
     if (isTop(supertype)) return true;
+
+    // Handle FutureOr<T> union type.

[Paul Berry, 2017/05/23 17:36:38]

Note: the logic below comes from the analyzer implementation--see
StrongTypeSystemImpl._isSubtypeOf
(pkg/analyzer/lib/src/generated/type_system.dart around line 882).

+    if (strongMode &&
+        subtype is InterfaceType &&
+        identical(subtype.classNode, futureOrClass)) {
+      var subtypeArg = subtype.typeArguments[0];
+      if (supertype is InterfaceType &&
+          identical(supertype.classNode, futureOrClass)) {
+        var supertypeArg = supertype.typeArguments[0];
+        // FutureOr<A> <: FutureOr<B> iff A <: B
+        return isSubtypeOf(subtypeArg, supertypeArg);
+      }
+
+      // given t1 is Future<A> | A, then:
+      // (Future<A> | A) <: t2 iff Future<A> <: t2 and A <: t2.
+      var subtypeFuture = futureType(subtypeArg);
+      return isSubtypeOf(subtypeFuture, supertype) &&
+          isSubtypeOf(subtypeArg, supertype);
+    }
+
+    if (strongMode &&
+        supertype is InterfaceType &&
+        identical(supertype.classNode, futureOrClass)) {
+      // given t2 is Future<A> | A, then:
+      // t1 <: (Future<A> | A) iff t1 <: Future<A> or t1 <: A
+      var supertypeArg = supertype.typeArguments[0];
+      var supertypeFuture = futureType(supertypeArg);
+      return isSubtypeOf(subtype, supertypeFuture) ||
+          isSubtypeOf(subtype, supertypeArg);
+    }
+
     if (subtype is InterfaceType && supertype is InterfaceType) {
       var upcastType =
           hierarchy.getTypeAsInstanceOf(subtype, supertype.classNode);
       if (upcastType == null) return false;
       for (int i = 0; i < upcastType.typeArguments.length; ++i) {
         // Termination: the 'supertype' parameter decreases in size.
         if (!isSubtypeOf(
             upcastType.typeArguments[i], supertype.typeArguments[i])) {
           return false;
         }
@@ skipping 71 matching lines @@
       if (subtypeNameIndex == subtype.namedParameters.length) return false;
       NamedType subtypeParameter = subtype.namedParameters[subtypeNameIndex];
       // Termination: Both types shrink in size.
       if (!isSubtypeOf(supertypeParameter.type, subtypeParameter.type)) {
         return false;
       }
     }
     return true;
   }
 }