Insert covariance checks in strong mode.

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';
 
@@ skipping 100 matching lines @@
   /// If both types are `int`, the returned type is `int`.
   /// If either type is `double`, the returned type is `double`.
   /// If both types refer to the same type variable (typically with `num` as
   /// the upper bound), then that type variable is returned.
   /// Otherwise `num` is returned.
   DartType getTypeOfOverloadedArithmetic(DartType type1, DartType type2) {
     if (type1 == type2) return type1;
     if (type1 == doubleType || type2 == doubleType) return doubleType;
     return numType;
   }
+
+  /// Returns true if [class_] has no proper subtypes that are usable as type
+  /// argument.
+  bool isSealedClass(Class class_) {
+    // The sealed core classes have subtypes in the patched SDK, but those
+    // classes cannot occur as type argument.
+    if (class_ == coreTypes.intClass ||
+        class_ == coreTypes.doubleClass ||
+        class_ == coreTypes.stringClass ||
+        class_ == coreTypes.boolClass ||
+        class_ == coreTypes.nullClass) {
+      return true;
+    }
+    return !hierarchy.hasProperSubtypes(class_);
+  }
 }
 
 /// 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;
 
@@ skipping 90 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;
   }
 }