Insert implicit downcasts in kernel strong mode.

pkg/kernel/lib/type_checker.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_checker;
 
 import 'ast.dart';
 import 'class_hierarchy.dart';
 import 'core_types.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
@@ skipping 67 matching lines @@
       checkAssignable(ownMember, getterType(host, ownMember),
           getterType(host, superMember));
     }
   }
 
   /// Check that [from] is a subtype of [to].
   ///
   /// [where] is an AST node indicating roughly where the check is required.
   void checkAssignable(TreeNode where, DartType from, DartType to);
 
+  /// Checks that [expression], which has type [from], can be assigned to [to].
+  ///
+  /// Should return a downcast if necessary, or [expression] if no cast is
+  /// needed.
+  Expression checkAndDowncastExpression(
+      Expression expression, DartType from, DartType to) {
+    checkAssignable(expression, from, to);
+    return expression;
+  }
+
   /// Indicates that type checking failed.
   void fail(TreeNode where, String message);
 }
 
 class TypeCheckingVisitor
     implements
         ExpressionVisitor<DartType>,
         StatementVisitor<Null>,
         MemberVisitor<Null>,
         InitializerVisitor<Null> {
   final TypeChecker checker;
   final TypeEnvironment environment;
 
   CoreTypes get coreTypes => environment.coreTypes;
   ClassHierarchy get hierarchy => environment.hierarchy;
   Class get currentClass => environment.thisType.classNode;
 
   TypeCheckingVisitor(this.checker, this.environment);
 
   void checkAssignable(TreeNode where, DartType from, DartType to) {
     checker.checkAssignable(where, from, to);
   }
 
-  void checkAssignableExpression(Expression from, DartType to) {
-    checker.checkAssignable(from, visitExpression(from), to);
+  Expression checkAndDowncastExpression(Expression from, DartType to) {
+    var parent = from.parent;
+    var type = visitExpression(from);
+    var result = checker.checkAndDowncastExpression(from, type, to);
+    result.parent = parent;
+    return result;
+  }
+
+  void checkExpressionNoDowncast(Expression expression, DartType to) {
+    checkAssignable(expression, visitExpression(expression), to);
   }
 
   void fail(TreeNode node, String message) {
     checker.fail(node, message);
   }
 
   DartType visitExpression(Expression node) => node.accept(this);
 
   void visitStatement(Statement node) {
     node.accept(this);
@@ skipping 16 matching lines @@
   defaultStatement(Statement node) {
     throw 'Unexpected statement ${node.runtimeType}';
   }
 
   defaultInitializer(Initializer node) {
     throw 'Unexpected initializer ${node.runtimeType}';
   }
 
   visitField(Field node) {
     if (node.initializer != null) {
-      checkAssignableExpression(node.initializer, node.type);
+      node.initializer =
+          checkAndDowncastExpression(node.initializer, node.type);
     }
   }
 
   visitConstructor(Constructor node) {
     environment.returnType = null;
     environment.yieldType = null;
     node.initializers.forEach(visitInitializer);
     handleFunctionNode(node.function);
   }
 
@@ skipping 21 matching lines @@
     var oldYield = environment.yieldType;
     environment.returnType = _getInternalReturnType(node);
     environment.yieldType = _getYieldType(node);
     handleFunctionNode(node);
     environment.returnType = oldReturn;
     environment.yieldType = oldYield;
   }
 
   void handleOptionalParameter(VariableDeclaration parameter) {
     if (parameter.initializer != null) {
-      checkAssignableExpression(parameter.initializer, parameter.type);
+      // Default parameter values cannot be downcast.
+      checkExpressionNoDowncast(parameter.initializer, parameter.type);
     }
   }
 
   Substitution getReceiverType(
       TreeNode access, Expression receiver, Member member) {
     var type = visitExpression(receiver);
     Class superclass = member.enclosingClass;
     if (superclass.supertype == null) {
       return Substitution.empty; // Members on Object are always accessible.
     }
@@ skipping 46 matching lines @@
     var substitution = Substitution.combine(receiver, instantiation);
     for (int i = 0; i < typeParameters.length; ++i) {
       var argument = arguments.types[i];
       var bound = substitution.substituteType(typeParameters[i].bound);
       checkAssignable(arguments, argument, bound);
     }
     for (int i = 0; i < arguments.positional.length; ++i) {
       var expectedType = substitution.substituteType(
           function.positionalParameters[i].type,
           contravariant: true);
-      checkAssignableExpression(arguments.positional[i], expectedType);
+      arguments.positional[i] =
+          checkAndDowncastExpression(arguments.positional[i], expectedType);
     }
     for (int i = 0; i < arguments.named.length; ++i) {
       var argument = arguments.named[i];
       bool found = false;
       for (int j = 0; j < function.namedParameters.length; ++j) {
         if (argument.name == function.namedParameters[j].name) {
           var expectedType = substitution.substituteType(
               function.namedParameters[j].type,
               contravariant: true);
-          checkAssignableExpression(argument.value, expectedType);
+          argument.value =
+              checkAndDowncastExpression(argument.value, expectedType);
           found = true;
           break;
         }
       }
       if (!found) {
         fail(argument.value, 'Unexpected named parameter: ${argument.name}');
         return const BottomType();
       }
     }
     return substitution.substituteType(function.returnType);
@@ skipping 58 matching lines @@
     return environment.unfutureType(visitExpression(node.operand));
   }
 
   @override
   DartType visitBoolLiteral(BoolLiteral node) {
     return environment.boolType;
   }
 
   @override
   DartType visitConditionalExpression(ConditionalExpression node) {
-    checkAssignableExpression(node.condition, environment.boolType);
-    checkAssignableExpression(node.then, node.staticType);
-    checkAssignableExpression(node.otherwise, node.staticType);
+    node.condition =
+        checkAndDowncastExpression(node.condition, environment.boolType);
+    node.then = checkAndDowncastExpression(node.then, node.staticType);
+    node.otherwise =
+        checkAndDowncastExpression(node.otherwise, node.staticType);
     return node.staticType;
   }
 
   @override
   DartType visitConstructorInvocation(ConstructorInvocation node) {
     Constructor target = node.target;
     Arguments arguments = node.arguments;
     Class class_ = target.enclosingClass;
     handleCall(arguments, target.function,
         typeParameters: class_.typeParameters);
@@ skipping 52 matching lines @@
   DartType visitLet(Let node) {
     var value = visitExpression(node.variable.initializer);
     if (node.variable.type is DynamicType) {
       node.variable.type = value;
     }
     return visitExpression(node.body);
   }
 
   @override
   DartType visitListLiteral(ListLiteral node) {
-    for (var item in node.expressions) {
-      checkAssignableExpression(item, node.typeArgument);
+    for (int i = 0; i < node.expressions.length; ++i) {
+      node.expressions[i] =
+          checkAndDowncastExpression(node.expressions[i], node.typeArgument);
     }
     return environment.literalListType(node.typeArgument);
   }
 
   @override
   DartType visitLogicalExpression(LogicalExpression node) {
-    checkAssignableExpression(node.left, environment.boolType);
-    checkAssignableExpression(node.right, environment.boolType);
+    node.left = checkAndDowncastExpression(node.left, environment.boolType);
+    node.right = checkAndDowncastExpression(node.right, environment.boolType);
     return environment.boolType;
   }
 
   @override
   DartType visitMapLiteral(MapLiteral node) {
     for (var entry in node.entries) {
-      checkAssignableExpression(entry.key, node.keyType);
-      checkAssignableExpression(entry.value, node.valueType);
+      entry.key = checkAndDowncastExpression(entry.key, node.keyType);
+      entry.value = checkAndDowncastExpression(entry.value, node.valueType);
     }
     return environment.literalMapType(node.keyType, node.valueType);
   }
 
   DartType handleDynamicCall(DartType receiver, Arguments arguments) {
     arguments.positional.forEach(visitExpression);
     arguments.named.forEach((NamedExpression n) => visitExpression(n.value));
     return const DynamicType();
   }
 
@@ skipping 10 matching lines @@
     if (function.typeParameters.length != arguments.types.length) {
       fail(access, 'Wrong number of type arguments');
       return const BottomType();
     }
     var instantiation =
         Substitution.fromPairs(function.typeParameters, arguments.types);
     for (int i = 0; i < arguments.positional.length; ++i) {
       var expectedType = instantiation.substituteType(
           function.positionalParameters[i],
           contravariant: true);
-      checkAssignableExpression(arguments.positional[i], expectedType);
+      arguments.positional[i] =
+          checkAndDowncastExpression(arguments.positional[i], expectedType);
     }
     for (int i = 0; i < arguments.named.length; ++i) {
       var argument = arguments.named[i];
       bool found = false;
       for (int j = 0; j < function.namedParameters.length; ++j) {
         if (argument.name == function.namedParameters[j].name) {
           var expectedType = instantiation.substituteType(
               function.namedParameters[j].type,
               contravariant: true);
-          checkAssignableExpression(argument.value, expectedType);
+          argument.value =
+              checkAndDowncastExpression(argument.value, expectedType);
           found = true;
           break;
         }
       }
       if (!found) {
         fail(argument.value, 'Unexpected named parameter: ${argument.name}');
         return const BottomType();
       }
     }
     return instantiation.substituteType(function.returnType);
@@ skipping 176 matching lines @@
 
   @override
   visitBreakStatement(BreakStatement node) {}
 
   @override
   visitContinueSwitchStatement(ContinueSwitchStatement node) {}
 
   @override
   visitDoStatement(DoStatement node) {
     visitStatement(node.body);
-    checkAssignableExpression(node.condition, environment.boolType);
+    node.condition =
+        checkAndDowncastExpression(node.condition, environment.boolType);
   }
 
   @override
   visitEmptyStatement(EmptyStatement node) {}
 
   @override
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
   }
 
   @override
   visitForInStatement(ForInStatement node) {
     var iterable = visitExpression(node.iterable);
     // TODO(asgerf): Store interface targets on for-in loops or desugar them,
     // instead of doing the ad-hoc resolution here.
     if (node.isAsync) {
       checkAssignable(node, getStreamElementType(iterable), node.variable.type);
     } else {
       checkAssignable(
           node, getIterableElementType(iterable), node.variable.type);
     }
     visitStatement(node.body);
   }
 
   static final Name iteratorName = new Name('iterator');
-  static final Name nextName = new Name('next');
+  static final Name currentName = new Name('current');
 
   DartType getIterableElementType(DartType iterable) {
     if (iterable is InterfaceType) {
       var iteratorGetter =
           hierarchy.getInterfaceMember(iterable.classNode, iteratorName);
       if (iteratorGetter == null) return const DynamicType();
+      var castedIterable = hierarchy.getTypeAsInstanceOf(
+          iterable, iteratorGetter.enclosingClass);
       var iteratorType = Substitution
-          .fromInterfaceType(iterable)
+          .fromInterfaceType(castedIterable)
           .substituteType(iteratorGetter.getterType);
       if (iteratorType is InterfaceType) {
-        var nextGetter =
-            hierarchy.getInterfaceMember(iteratorType.classNode, nextName);
-        if (nextGetter == null) return const DynamicType();
+        var currentGetter =
+            hierarchy.getInterfaceMember(iteratorType.classNode, currentName);
+        if (currentGetter == null) return const DynamicType();
+        var castedIteratorType = hierarchy.getTypeAsInstanceOf(
+            iteratorType, currentGetter.enclosingClass);
         return Substitution
-            .fromInterfaceType(iteratorType)
-            .substituteType(nextGetter.getterType);
+            .fromInterfaceType(castedIteratorType)
+            .substituteType(currentGetter.getterType);
       }
     }
     return const DynamicType();
   }
 
   DartType getStreamElementType(DartType stream) {
     if (stream is InterfaceType) {
       var asStream =
           hierarchy.getTypeAsInstanceOf(stream, coreTypes.streamClass);
       if (asStream == null) return const DynamicType();
       return asStream.typeArguments.single;
     }
     return const DynamicType();
   }
 
   @override
   visitForStatement(ForStatement node) {
     node.variables.forEach(visitVariableDeclaration);
     if (node.condition != null) {
-      checkAssignableExpression(node.condition, environment.boolType);
+      node.condition =
+          checkAndDowncastExpression(node.condition, environment.boolType);
     }
     node.updates.forEach(visitExpression);
     visitStatement(node.body);
   }
 
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     handleNestedFunctionNode(node.function);
   }
 
   @override
   visitIfStatement(IfStatement node) {
-    checkAssignableExpression(node.condition, environment.boolType);
+    node.condition =
+        checkAndDowncastExpression(node.condition, environment.boolType);
     visitStatement(node.then);
     if (node.otherwise != null) {
       visitStatement(node.otherwise);
     }
   }
 
   @override
   visitInvalidStatement(InvalidStatement node) {}
 
   @override
@@ skipping 35 matching lines @@
 
   @override
   visitTryFinally(TryFinally node) {
     visitStatement(node.body);
     visitStatement(node.finalizer);
   }
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.initializer != null) {
-      checkAssignableExpression(node.initializer, node.type);
+      node.initializer =
+          checkAndDowncastExpression(node.initializer, node.type);
     }
   }
 
   @override
   visitWhileStatement(WhileStatement node) {
-    checkAssignableExpression(node.condition, environment.boolType);
+    node.condition =
+        checkAndDowncastExpression(node.condition, environment.boolType);
     visitStatement(node.body);
   }
 
   @override
   visitYieldStatement(YieldStatement node) {
     if (node.isYieldStar) {
       Class container = environment.currentAsyncMarker == AsyncMarker.AsyncStar
           ? coreTypes.streamClass
           : coreTypes.iterableClass;
       var type = visitExpression(node.expression);
       var asContainer = type is InterfaceType
           ? hierarchy.getTypeAsInstanceOf(type, container)
           : null;
       if (asContainer != null) {
         checkAssignable(node.expression, asContainer.typeArguments[0],
             environment.yieldType);
       } else {
         fail(node.expression, '$type is not an instance of $container');
       }
     } else {
-      checkAssignableExpression(node.expression, environment.yieldType);
+      node.expression =
+          checkAndDowncastExpression(node.expression, environment.yieldType);
     }
   }
 
   @override
   visitFieldInitializer(FieldInitializer node) {
-    checkAssignableExpression(node.value, node.field.type);
+    node.value = checkAndDowncastExpression(node.value, node.field.type);
   }
 
   @override
   visitRedirectingInitializer(RedirectingInitializer node) {
     handleCall(node.arguments, node.target.function,
         typeParameters: const <TypeParameter>[]);
   }
 
   @override
   visitSuperInitializer(SuperInitializer node) {
     handleCall(node.arguments, node.target.function,
-        typeParameters: const <TypeParameter>[]);
+        typeParameters: const <TypeParameter>[],
+        receiver: getSuperReceiverType(node.target));
   }
 
   @override
   visitLocalInitializer(LocalInitializer node) {
     visitVariableDeclaration(node.variable);
   }
 
   @override
   visitInvalidInitializer(InvalidInitializer node) {}
 }