Insert implicit downcasts in kernel 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 77 matching lines @@
 
   /// True if [member] is a binary operator that returns an `int` if both
   /// operands are `int`, and otherwise returns `double`.
   ///
   /// This is a case of type-based overloading, which in Dart is only supported
   /// by giving special treatment to certain arithmetic operators.
   bool isOverloadedArithmeticOperator(Procedure member) {
     Class class_ = member.enclosingClass;
     if (class_ == coreTypes.intClass || class_ == coreTypes.numClass) {
       String name = member.name.name;
-      return name == '+' || name == '-' || name == '*' || name == 'remainder';
+      return name == '+' ||
+          name == '-' ||
+          name == '*' ||
+          name == 'remainder' ||
+          name == '%';
     }
     return false;
   }
 
   /// Returns the static return type of an overloaded arithmetic operator
   /// (see [isOverloadedArithmeticOperator]) given the static type of the
   /// operands.
   ///
   /// If both types are `int`, the returned type is `int`.
   /// If either type is `double`, the returned type is `double`.
@@ skipping 12 matching lines @@
 /// 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;
 
   /// Returns true if [subtype] is a subtype of [supertype].
   bool isSubtypeOf(DartType subtype, DartType supertype) {
     if (identical(subtype, supertype)) return true;
     if (subtype is BottomType) return true;
-    if (supertype is DynamicType || supertype == objectType) {
+    if (supertype is DynamicType ||
+        supertype is VoidType ||
+        supertype == objectType) {
       return true;
     }
     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])) {
@@ skipping 45 matching lines @@
         var subBound = substitute(subParameter.bound, substitution);
         // Termination: if there are no cyclically bound type parameters, this
         // recursive call can only occur a finite number of times before
         // reaching a shrinking recursive call (or terminating).
         if (!isSubtypeOf(superParameter.bound, subBound)) {
           return false;
         }
       }
       subtype = substitute(subtype.withoutTypeParameters, substitution);
     }
-    if (supertype.returnType is! VoidType &&
-        !isSubtypeOf(subtype.returnType, supertype.returnType)) {
+    if (!isSubtypeOf(subtype.returnType, supertype.returnType)) {
       return false;
     }
     for (int i = 0; i < supertype.positionalParameters.length; ++i) {
       var supertypeParameter = supertype.positionalParameters[i];
       var subtypeParameter = subtype.positionalParameters[i];
       // Termination: Both types shrink in size.
       if (!isSubtypeOf(supertypeParameter, subtypeParameter)) {
         return false;
       }
     }
     int subtypeNameIndex = 0;
     for (NamedType supertypeParameter in supertype.namedParameters) {
       while (subtypeNameIndex < subtype.namedParameters.length &&
           subtype.namedParameters[subtypeNameIndex].name !=
               supertypeParameter.name) {
         ++subtypeNameIndex;
       }
       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;
   }
 }