Support annotations on assignment and postfix operations

tests/compiler/dart2js/inference/inference_test_helper.dart

 // Copyright (c) 2017, 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.
 
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
@@ skipping 47 matching lines @@
     with ComputeValueMixin<ast.Node> {
   final GlobalTypeInferenceResults<ast.Node> results;
   final GlobalTypeInferenceElementResult<ast.Node> result;
 
   TypeMaskComputer(DiagnosticReporter reporter, Map<Id, ActualData> actualMap,
       ResolvedAst resolvedAst, this.results)
       : result = results.resultOfMember(resolvedAst.element as MemberElement),
         super(reporter, actualMap, resolvedAst);
 
   @override
-  String computeElementValue(AstElement element) {
+  String computeElementValue(Id id, AstElement element) {
     if (element.isParameter) {
       ParameterElement parameter = element;
       return getParameterValue(parameter);
     } else if (element.isLocal) {
       LocalFunctionElement localFunction = element;
       return getMemberValue(localFunction.callMethod);
     } else {
       MemberElement member = element;
       return getMemberValue(member);
     }
   }
 
   @override
-  String computeNodeValue(ast.Node node, [AstElement element]) {
+  String computeNodeValue(Id id, ast.Node node, [AstElement element]) {
     if (node is ast.Send) {
       return getTypeMaskValue(result.typeOfSend(node));
     } else if (element != null && element.isLocal) {
-      return computeElementValue(element);
+      return computeElementValue(id, element);
     }
     return null;
   }
 }
 
 /// Compute type inference data for [member] from kernel based inference.
 ///
 /// Fills [actualMap] with the data.
 void computeMemberIrTypeMasks(
     Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap,
     {bool verbose: false}) {
   KernelBackendStrategy backendStrategy = compiler.backendStrategy;
   KernelToElementMapForBuilding elementMap = backendStrategy.elementMap;
   GlobalLocalsMap localsMap = backendStrategy.globalLocalsMapForTesting;
   MemberDefinition definition = elementMap.getMemberDefinition(member);
   new TypeMaskIrComputer(
+          compiler.reporter,
           actualMap,
           elementMap,
           member,
           localsMap.getLocalsMap(member),
           compiler.globalInference.results,
           backendStrategy.closureDataLookup as ClosureDataLookup<ir.Node>)
       .run(definition.node);
 }
 
 /// AST visitor for computing inference data for a member.
 class TypeMaskIrComputer extends IrDataExtractor
     with ComputeValueMixin<ir.Node> {
   final GlobalTypeInferenceResults<ir.Node> results;
   final GlobalTypeInferenceElementResult<ir.Node> result;
   final KernelToElementMapForBuilding _elementMap;
   final KernelToLocalsMap _localsMap;
   final ClosureDataLookup<ir.Node> _closureDataLookup;
 
   TypeMaskIrComputer(
+      DiagnosticReporter reporter,
       Map<Id, ActualData> actualMap,
       this._elementMap,
       MemberEntity member,
       this._localsMap,
       this.results,
       this._closureDataLookup)
       : result = results.resultOfMember(member),
-        super(actualMap);
+        super(reporter, actualMap);
 
   @override
-  String computeMemberValue(ir.Member node) {
+  String computeMemberValue(Id id, ir.Member node) {
     return getMemberValue(_elementMap.getMember(node));
   }
 
   @override
-  String computeNodeValue(ir.TreeNode node) {
+  String computeNodeValue(Id id, ir.TreeNode node) {
     if (node is ir.VariableDeclaration && node.parent is ir.FunctionNode) {
       Local parameter = _localsMap.getLocalVariable(node);
       return getParameterValue(parameter);
     } else if (node is ir.FunctionExpression ||
         node is ir.FunctionDeclaration) {
       ClosureRepresentationInfo info = _closureDataLookup.getClosureInfo(node);
       return getMemberValue(info.callMethod);
     } else if (node is ir.MethodInvocation) {
       return getTypeMaskValue(result.typeOfSend(node));
     }
     return null;
   }
 }