fix #26912, correct handling of op assign

pkg/analyzer/lib/src/generated/static_type_analyzer.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 240 matching lines @@
       }
       _resolver.overrideExpression(node.leftHandSide, overrideType, true, true);
     } else if (operator == TokenType.QUESTION_QUESTION_EQ) {
       // The static type of a compound assignment using ??= is the least upper
       // bound of the static types of the LHS and RHS.
       _analyzeLeastUpperBound(node, node.leftHandSide, node.rightHandSide);
       return null;
     } else {
       ExecutableElement staticMethodElement = node.staticElement;
       DartType staticType = _computeStaticReturnType(staticMethodElement);
-      staticType =
-          _refineAssignmentExpressionType(node, staticType, _getStaticType);
+      staticType = _typeSystem.refineBinaryExpressionType(
+          _typeProvider,
+          node.leftHandSide.staticType,
+          operator,
+          node.rightHandSide.staticType,
+          staticType);
       _recordStaticType(node, staticType);
       MethodElement propagatedMethodElement = node.propagatedElement;
       if (!identical(propagatedMethodElement, staticMethodElement)) {
         DartType propagatedType =
             _computeStaticReturnType(propagatedMethodElement);
+        propagatedType = _typeSystem.refineBinaryExpressionType(
+            _typeProvider,
+            node.leftHandSide.propagatedType,
+            operator,
+            node.rightHandSide.propagatedType,
+            propagatedType);
         _resolver.recordPropagatedTypeIfBetter(node, propagatedType);
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 16.29 (Await Expressions):
    *
    *   The static type of [the expression "await e"] is flatten(T) where T is
@@ skipping 1947 matching lines @@
    */
   void _recordStaticType(Expression expression, DartType type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
   }
 
   /**
-   * Attempts to make a better guess for the type of the given assignment
-   * [expression], given that resolution has so far produced the [currentType].
-   * The [typeAccessor] is used to access the corresponding type of the left
-   * and right operands.
-   */
-  DartType _refineAssignmentExpressionType(AssignmentExpression expression,
-      DartType currentType, DartType typeAccessor(Expression node)) {
-    Expression leftHandSize = expression.leftHandSide;
-    Expression rightHandSide = expression.rightHandSide;
-    TokenType operator = expression.operator.type;
-    DartType intType = _typeProvider.intType;
-    if (typeAccessor(leftHandSize) == intType) {
-      // int op= double
-      if (operator == TokenType.MINUS_EQ ||
-          operator == TokenType.PERCENT_EQ ||
-          operator == TokenType.PLUS_EQ ||
-          operator == TokenType.STAR_EQ) {
-        DartType doubleType = _typeProvider.doubleType;
-        if (typeAccessor(rightHandSide) == doubleType) {
-          return doubleType;
-        }
-      }
-      // int op= int
-      if (operator == TokenType.MINUS_EQ ||
-          operator == TokenType.PERCENT_EQ ||
-          operator == TokenType.PLUS_EQ ||
-          operator == TokenType.STAR_EQ ||
-          operator == TokenType.TILDE_SLASH_EQ) {
-        if (typeAccessor(rightHandSide) == intType) {
-          return intType;
-        }
-      }
-    }
-    // default
-    return currentType;
-  }
-
-  /**
    * Create a table mapping HTML tag names to the names of the classes (in 'dart:html') that
    * implement those tags.
    *
    * @return the table that was created
    */
   static HashMap<String, String> _createHtmlTagToClassMap() {
     HashMap<String, String> map = new HashMap<String, String>();
     map["a"] = "AnchorElement";
     map["area"] = "AreaElement";
     map["br"] = "BRElement";
@@ skipping 80 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }