fix #27110, mark implicit downcasts for op assign

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 168 matching lines @@
     NodeList<Expression> list = node.arguments;
     int len = list.length;
     for (int i = 0; i < len; ++i) {
       Expression arg = list[i];
       ParameterElement element = arg.staticParameterElement;
       if (element == null) {
         // We found an argument mismatch, the analyzer will report this too,
         // so no need to insert an error for this here.
         continue;
       }
-      DartType expectedType = _elementType(element);
-      if (expectedType == null) expectedType = DynamicTypeImpl.instance;
-      checkArgument(arg, expectedType);
+      checkArgument(arg, _elementType(element));
     }
   }
 
   void checkAssignment(Expression expr, DartType type) {
     if (expr is ParenthesizedExpression) {
       checkAssignment(expr.expression, type);
     } else {
       if (_checkNonNullAssignment(expr, type)) {
         _checkDowncast(expr, type);
       }
@@ skipping 492 matching lines @@
       _recordDynamicInvoke(expr, expr.leftHandSide);
     } else {
       // 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.
+      // Refine the return type.
       var rhsType = _getDefiniteType(expr.rightHandSide);
       var lhsType = _getDefiniteType(expr.leftHandSide);
       var returnType = rules.refineBinaryExpressionType(
           typeProvider, lhsType, op, rhsType, functionType.returnType);
 
-      if (!rules.isSubtypeOf(returnType, lhsType)) {
-        final numType = typeProvider.numType;
-        // TODO(jmesserly): this seems to duplicate logic in StaticTypeAnalyzer.
-        // 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.
-          _recordImplicitCast(expr.rightHandSide, rhsType, lhsType);
-        } else {
-          // TODO(jmesserly): this results in a duplicate error, because
-          // ErrorVerifier also reports it.
-          _recordMessage(expr, StrongModeCode.STATIC_TYPE_ERROR,
-              [expr, returnType, lhsType]);
-        }
-      } else {
-        // Check the RHS type.
-        //
-        // This is only needed if we didn't already need a cast, and avoids
-        // emitting two messages for the same expression.
-        _checkDowncast(expr.rightHandSide, paramTypes.first);
-      }
+      // Check the argument for an implicit cast.
+      _checkDowncast(expr.rightHandSide, paramTypes[0], from: rhsType);

[Jennifer Messerly, 2016/08/25 22:27:15]

this is my attempt to fix by simplification :)

[Leaf, 2016/08/25 22:35:34]

:)

+
+      // Check the return type for an implicit cast.
+      //
+      // If needed, mark the left size to indicate a down cast when we assign

[Leaf, 2016/08/25 22:35:34]

size -> side?

+      // back to it. so these two implicit casts are equivalent:
+      //
+      //     y = /*implicit cast*/(y + 42);
+      //     y/*implicit cast*/ += 42;
+      //
+      // TODO(jmesserly): this is an unambiguous way to represent it, but it's

[Jennifer Messerly, 2016/08/25 22:27:15]

https://github.com/dart-lang/dev_compiler/issues/632 for the DDC side

+      // a bit sneaky. We can't use the rightHandSide because that could be a
+      // downcast on its own, and we can't use the entire expression because its
+      // result value could used and then implicitly downcast.
+      _checkDowncast(expr.leftHandSide, lhsType, from: returnType);
     }
   }
 
   /// Records a [DownCast] of [expr] from [from] to [to], if there is one.
   ///
   /// If [from] is omitted, uses the static type of [expr].
   ///
   /// If [expr] does not require a downcast because it is not related to [to]
   /// or is already a subtype of it, does nothing.
   void _checkDowncast(Expression expr, DartType to, {DartType from}) {
@@ skipping 735 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }