fix #28008, fix #28009 implement FutureOr<T>

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/types.dart

 // Copyright (c) 2015, 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.
 
 /// This library defines the representation of runtime types.
 part of dart._runtime;
 
 final metadata = JS('', 'Symbol("metadata")');
 
 /// The symbol used to store the cached `Type` object associated with a class.
@@ skipping 642 matching lines @@
     }
   }
 
   // Check return type last, so that arity mismatched functions can be
   // definitively rejected.
 
   // We allow any type to subtype a void return type, but not vice versa
   if (ret2 === $_void) return true;
   // Dart allows void functions to subtype dynamic functions, but not
   // other functions.
-  if (ret1 === $_void) return (ret2 === $dynamic);
+  // TODO(jmesserly): this check does not match our compile time subtype
+  // implementation. Reconcile.
+  if (ret1 === $_void) {
+    return ret2 === $dynamic || ret2 === $FutureOr;
+  }
   if (!$_isSubtype(ret1, ret2, $isCovariant)) return null;
   return true;
 })()''');
 
 /// TODO(leafp): This duplicates code in operations.dart.
 /// I haven't found a way to factor it out that makes the
 /// code generator happy though.
 _subtypeMemo(f) => JS(
     '',
     '''(() => {
@@ skipping 15 matching lines @@
 
 /// Returns true if [t1] <: [t2].
 /// Returns false if [t1] </: [t2] in both spec and strong mode
 /// Returns undefined if [t1] </: [t2] in strong mode, but spec
 ///  mode may differ
 final isSubtype = JS(
     '', '$_subtypeMemo((t1, t2) => (t1 === t2) || $_isSubtype(t1, t2, true))');
 
 _isBottom(type) => JS('bool', '# == #', type, bottom);
 
-_isTop(type) => JS('bool', '# == # || # == #', type, Object, type, dynamic);
+_isTop(type) {
+  if (JS('bool', '# === #', getGenericClass(type), getGenericClass(FutureOr))) {
+    return _isTop(JS('', '#[0]', getGenericArgs(type)));
+  }
+  return JS('bool', '# == # || # == #', type, Object, type, dynamic);
+}
 
 _isSubtype(t1, t2, isCovariant) => JS(
     '',
     '''(() => {
   if ($t1 === $t2) return true;
 
   // Trivially true.
   if ($_isTop($t2) || $_isBottom($t1)) {
     return true;
   }
@@ skipping 67 matching lines @@
     for (let i = 0; i < length; ++i) {
       let result =
           $_isSubtype(typeArguments1[i], typeArguments2[i], $isCovariant);
       if (!result) {
         return result;
       }
     }
     return true;
   }
 
+  // Handle FutureOr<T>.
+  // It's not really a class type, but it's convenient to handle here.
+  if (raw1 === ${getGenericClass(FutureOr)}) {
+    // given t1 is Future<A> | A, then:
+    // (Future<A> | A) <: t2 iff Future<A> <: t2 and A <: t2.
+    let t1TypeArg = $getGenericArgs($t1)[0];
+    let t1Future = ${getGenericClass(Future)}(t1TypeArg);
+    return $isSubtype(t1Future, $t2) && $isSubtype(t1TypeArg, $t2);
+  } else if (raw2 === ${getGenericClass(FutureOr)}) {
+    // given t2 is Future<A> | A, then:
+    // t1 <: (Future<A> | A) iff t1 <: Future<A> or t1 <: A
+    let t2TypeArg = $getGenericArgs($t2)[0];
+    let t2Future = ${getGenericClass(Future)}(t2TypeArg);
+    return $isSubtype($t1, t2Future) || $isSubtype($t1, t2TypeArg);
+  }
+
   let indefinite = false;
   function definitive(t1, t2) {
     let result = $isClassSubType(t1, t2, $isCovariant);
     if (result == null) {
       indefinite = true;
       return false;
     }
     return result;
   }
 
@@ skipping 48 matching lines @@
     return true;
   }
 
   let typeArgs = $getGenericArgs($type);
   if (!typeArgs) return true;
   for (let t of typeArgs) {
     if (t != $Object && t != $dynamic) return false;
   }
   return true;
 })()''');