Don't report redundant type errors in strong mode.

pkg/analyzer/lib/src/task/strong/checker.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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 127 matching lines @@
       DartType expectedType = _elementType(element);
       if (expectedType == null) expectedType = DynamicTypeImpl.instance;
       checkArgument(arg, expectedType);
     }
   }
 
   void checkAssignment(Expression expr, DartType type) {
     if (expr is ParenthesizedExpression) {
       checkAssignment(expr.expression, type);
     } else {
-      _recordMessage(_checkAssignment(expr, type));
+      _checkDowncast(expr, type);
     }
   }
 
   /// Analyzer checks boolean conversions, but we need to check too, because
   /// it uses the default assignability rules that allow `dynamic` and `Object`
   /// to be assigned to bool with no message.
   void checkBoolean(Expression expr) =>
       checkAssignment(expr, typeProvider.boolType);
 
   void checkFunctionApplication(
@@ skipping 399 matching lines @@
     checkBoolean(node.condition);
     node.visitChildren(this);
   }
 
   @override
   void visitYieldStatement(YieldStatement node) {
     _checkReturnOrYield(node.expression, node, yieldStar: node.star != null);
     node.visitChildren(this);
   }
 
-  StaticInfo _checkAssignment(Expression expr, DartType toT) {
-    final fromT = _getStaticType(expr);
-    final Coercion c = _coerceTo(fromT, toT);
-    if (c is Identity) return null;
-    if (c is CoercionError) return new StaticTypeError(rules, expr, toT);
-    if (c is Cast) return DownCast.create(rules, expr, c);
-    assert(false);
-    return null;
-  }
-
   void _checkCompoundAssignment(AssignmentExpression expr) {
     var op = expr.operator.type;
     assert(op.isAssignmentOperator && op != TokenType.EQ);
     var methodElement = expr.staticElement;
     if (methodElement == null) {
-      // Dynamic invocation
+      // Dynamic invocation.
       _recordDynamicInvoke(expr, expr.leftHandSide);
     } else {
-      // Sanity check the operator
+      // Sanity check the operator.
       assert(methodElement.isOperator);
       var functionType = methodElement.type;
       var paramTypes = functionType.normalParameterTypes;
       assert(paramTypes.length == 1);
       assert(functionType.namedParameterTypes.isEmpty);
       assert(functionType.optionalParameterTypes.isEmpty);
 
-      // Check the lhs type
+      // Check the LHS type.
       var staticInfo;
       var rhsType = _getStaticType(expr.rightHandSide);
       var lhsType = _getStaticType(expr.leftHandSide);
       var returnType = _specializedBinaryReturnType(
           op, lhsType, rhsType, functionType.returnType);
 
       if (!rules.isSubtypeOf(returnType, lhsType)) {
         final numType = typeProvider.numType;
         // Try to fix up the numerical case if possible.
         if (rules.isSubtypeOf(lhsType, numType) &&
             rules.isSubtypeOf(lhsType, rhsType)) {
           // This is also slightly different from spec, but allows us to keep
           // compound operators in the int += num and num += dynamic cases.
           staticInfo = DownCast.create(
-              rules, expr.rightHandSide, Coercion.cast(rhsType, lhsType));
+              rules, expr.rightHandSide, new Cast(rhsType, lhsType));
           rhsType = lhsType;
         } else {
-          // Static type error
           staticInfo = new StaticTypeError(rules, expr, lhsType);
         }
         _recordMessage(staticInfo);
       }
 
       // Check the rhs type
       if (staticInfo is! CoercionInfo) {
         var paramType = paramTypes.first;
-        staticInfo = _checkAssignment(expr.rightHandSide, paramType);
-        _recordMessage(staticInfo);
+        _checkDowncast(expr.rightHandSide, paramType);
       }
     }
   }
 
   void _checkFieldAccess(AstNode node, AstNode target, SimpleIdentifier field) {
     if ((_isDynamicTarget(target) || field.staticElement == null) &&
         !_isObjectProperty(target, field)) {
       _recordDynamicInvoke(node, target);
     }
     node.visitChildren(this);
@@ skipping 35 matching lines @@
         op.type == TokenType.MINUS_MINUS) {
       if (_isDynamicTarget(node.operand)) {
         _recordDynamicInvoke(node, node.operand);
       }
       // For ++ and --, even if it is not dynamic, we still need to check
       // that the user defined method accepts an `int` as the RHS.
       // We assume Analyzer has done this already.
     }
   }
 
-  Coercion _coerceTo(DartType fromT, DartType toT) {
-    // We can use anything as void
-    if (toT.isVoid) return Coercion.identity(toT);
+  /// Records a [DownCast] of [expr] to [toT], if there is one.
+  ///
+  /// If [expr] does not require a downcast because it is not related to [toT]
+  /// or is already a subtype of it, does nothing.
+  void _checkDowncast(Expression expr, DartType toT) {
+    DartType fromT = _getStaticType(expr);
 
-    // fromT <: toT, no coercion needed
-    if (rules.isSubtypeOf(fromT, toT)) return Coercion.identity(toT);
+    // We can use anything as void.
+    if (toT.isVoid) return;
+
+    // fromT <: toT, no coercion needed.
+    if (rules.isSubtypeOf(fromT, toT)) return;
 
     // TODO(vsm): We can get rid of the second clause if we disallow
     // all sideways casts - see TODO below.
     // -------
     // Note: a function type is never assignable to a class per the Dart
     // spec - even if it has a compatible call method.  We disallow as
     // well for consistency.
     if ((fromT is FunctionType && rules.getCallMethodType(toT) != null) ||
         (toT is FunctionType && rules.getCallMethodType(fromT) != null)) {
-      return Coercion.error();
+      return;
     }
 
     // Downcast if toT <: fromT
-    if (rules.isSubtypeOf(toT, fromT)) return Coercion.cast(fromT, toT);
+    if (rules.isSubtypeOf(toT, fromT)) {
+      _recordMessage(DownCast.create(rules, expr, new Cast(fromT, toT)));
+      return;
+    }
 
     // TODO(vsm): Once we have generic methods, we should delete this
     // workaround.  These sideways casts are always ones we warn about
     // - i.e., we think they are likely to fail at runtime.
     // -------
     // Downcast if toT <===> fromT
     // The intention here is to allow casts that are sideways in the restricted
     // type system, but allowed in the regular dart type system, since these
     // are likely to succeed.  The canonical example is List<dynamic> and
     // Iterable<T> for some concrete T (e.g. Object).  These are unrelated
     // in the restricted system, but List<dynamic> <: Iterable<T> in dart.
     if (fromT.isAssignableTo(toT)) {
-      return Coercion.cast(fromT, toT);
+      _recordMessage(DownCast.create(rules, expr, new Cast(fromT, toT)));
     }
-
-    return Coercion.error();
   }
 
   // Produce a coercion which coerces something of type fromT
   // to something of type toT.
   // Returns the error coercion if the types cannot be coerced
   // according to our current criteria.
   /// Gets the expected return type of the given function [body], either from
   /// a normal return/yield, or from a yield*.
   DartType _getExpectedReturnType(FunctionBody body, {bool yieldStar: false}) {
     FunctionType functionType;
@@ skipping 552 matching lines @@
     } while (!current.isObject && !visited.contains(current));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     _reporter.onError(error);
   }
 }