Support annotations on assignment and postfix operations

tests/compiler/dart2js/closure/closure_test.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 'dart:io' hide Link;
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
@@ skipping 41 matching lines @@
 void computeKernelClosureData(
     Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap,
     {bool verbose: false}) {
   KernelBackendStrategy backendStrategy = compiler.backendStrategy;
   KernelToElementMapForBuilding elementMap = backendStrategy.elementMap;
   GlobalLocalsMap localsMap = backendStrategy.globalLocalsMapForTesting;
   ClosureDataLookup closureDataLookup = backendStrategy.closureDataLookup;
   MemberDefinition definition = elementMap.getMemberDefinition(member);
   assert(definition.kind == MemberKind.regular,
       failedAt(member, "Unexpected member definition $definition"));
-  new ClosureIrChecker(actualMap, elementMap, member,
+  new ClosureIrChecker(compiler.reporter, actualMap, elementMap, member,
           localsMap.getLocalsMap(member), closureDataLookup,
           verbose: verbose)
       .run(definition.node);
 }
 
 /// Ast visitor for computing closure data.
 class ClosureAstComputer extends AstDataExtractor with ComputeValueMixin {
   final ClosureDataLookup<ast.Node> closureDataLookup;
   final bool verbose;
 
@@ skipping 11 matching lines @@
       pushLocalFunction(node);
       super.visitFunctionExpression(node);
       popLocalFunction();
       popMember();
     } else {
       super.visitFunctionExpression(node);
     }
   }
 
   @override
-  String computeNodeValue(ast.Node node, [AstElement element]) {
+  String computeNodeValue(Id id, ast.Node node, [AstElement element]) {
     if (element != null && element.isLocal) {
       if (element.isFunction) {
         LocalFunctionElement localFunction = element;
         return computeObjectValue(localFunction.callMethod);
       } else {
         LocalElement local = element;
         return computeLocalValue(local);
       }
     }
     // TODO(johnniwinther,efortuna): Collect data for other nodes?
     return null;
   }
 
   @override
-  String computeElementValue(covariant MemberElement element) {
+  String computeElementValue(Id id, covariant MemberElement element) {
     // TODO(johnniwinther,efortuna): Collect data for the member
     // (has thisLocal, has box, etc.).
     return computeObjectValue(element);
   }
 }
 
 /// Kernel IR visitor for computing closure data.
 class ClosureIrChecker extends IrDataExtractor with ComputeValueMixin<ir.Node> {
   final MemberEntity member;
   final ClosureDataLookup<ir.Node> closureDataLookup;
   final KernelToLocalsMap _localsMap;
   final bool verbose;
 
   ClosureIrChecker(
+      DiagnosticReporter reporter,
       Map<Id, ActualData> actualMap,
       KernelToElementMapForBuilding elementMap,
       this.member,
       this._localsMap,
       this.closureDataLookup,
       {this.verbose: false})
-      : super(actualMap) {
+      : super(reporter, actualMap) {
     pushMember(member);
   }
 
   visitFunctionExpression(ir.FunctionExpression node) {
     ClosureRepresentationInfo info = closureDataLookup.getClosureInfo(node);
     pushMember(info.callMethod);
     pushLocalFunction(node);
     super.visitFunctionExpression(node);
     popLocalFunction();
     popMember();
   }
 
   visitFunctionDeclaration(ir.FunctionDeclaration node) {
     ClosureRepresentationInfo info = closureDataLookup.getClosureInfo(node);
     pushMember(info.callMethod);
     pushLocalFunction(node);
     super.visitFunctionDeclaration(node);
     popLocalFunction();
     popMember();
   }
 
   @override
-  String computeNodeValue(ir.Node node) {
+  String computeNodeValue(Id id, ir.Node node) {
     if (node is ir.VariableDeclaration) {
-      if (node.parent is ir.FunctionDeclaration) {
-        ClosureRepresentationInfo info =
-            closureDataLookup.getClosureInfo(node.parent);
-        return computeObjectValue(info.callMethod);
-      }
       Local local = _localsMap.getLocalVariable(node);
       return computeLocalValue(local);
+    } else if (node is ir.FunctionDeclaration) {
+      ClosureRepresentationInfo info = closureDataLookup.getClosureInfo(node);
+      return computeObjectValue(info.callMethod);
     } else if (node is ir.FunctionExpression) {
       ClosureRepresentationInfo info = closureDataLookup.getClosureInfo(node);
       return computeObjectValue(info.callMethod);
     }
     return null;
   }
 
   @override
-  String computeMemberValue(ir.Member node) {
+  String computeMemberValue(Id id, ir.Member node) {
     return computeObjectValue(member);
   }
 }
 
 abstract class ComputeValueMixin<T> {
   bool get verbose;
   Map<BoxLocal, String> boxNames = <BoxLocal, String>{};
   ClosureDataLookup<T> get closureDataLookup;
   Link<ScopeInfo> scopeInfoStack = const Link<ScopeInfo>();
   ScopeInfo get scopeInfo => scopeInfoStack.head;
@@ skipping 130 matching lines @@
         if (value != '') {
           sb.write('=');
           sb.write(value);
         }
         needsComma = true;
       }
     }
     return sb.toString();
   }
 }