Support annotations on assignment and postfix operations

tests/compiler/dart2js/equivalence/id_equivalence_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 'dart:async';
 import 'dart:io';
 
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/compiler.dart';
@@ skipping 45 matching lines @@
 /// Actual data is computed using [computeMemberData] and [code] is compiled
 /// using [compileFunction].
 Future<IdData> computeData(
     String annotatedCode,
     ComputeMemberDataFunction computeMemberData,
     CompileFunction compileFunction,
     {List<String> options: const <String>[],
     bool verbose: false}) async {
   AnnotatedCode code =
       new AnnotatedCode.fromText(annotatedCode, commentStart, commentEnd);
-  Map<Id, String> expectedMap = computeExpectedMap(code);
+  Map<Id, IdValue> expectedMap = computeExpectedMap(code);
   Map<Id, ActualData> actualMap = <Id, ActualData>{};
   Uri mainUri = Uri.parse('memory:main.dart');
   Compiler compiler = await compileFunction(code, mainUri, options);
   ElementEnvironment elementEnvironment =
       compiler.backendClosedWorldForTesting.elementEnvironment;
   LibraryEntity mainLibrary = elementEnvironment.mainLibrary;
   elementEnvironment.forEachClass(mainLibrary, (ClassEntity cls) {
     elementEnvironment.forEachClassMember(cls,
         (ClassEntity declarer, MemberEntity member) {
       if (cls == declarer) {
         computeMemberData(compiler, member, actualMap, verbose: verbose);
       }
     });
   });
   elementEnvironment.forEachLibraryMember(mainLibrary, (MemberEntity member) {
     computeMemberData(compiler, member, actualMap, verbose: verbose);
   });
   return new IdData(
       code, compiler, elementEnvironment, mainUri, expectedMap, actualMap);
 }
 
 /// Data collected by [computeData].
 class IdData {
   final AnnotatedCode code;
   final Compiler compiler;
   final ElementEnvironment elementEnvironment;
   final Uri mainUri;
-  final Map<Id, String> expectedMap;
+  final Map<Id, IdValue> expectedMap;
   final Map<Id, ActualData> actualMap;
 
   IdData(this.code, this.compiler, this.elementEnvironment, this.mainUri,
       this.expectedMap, this.actualMap);
 
-  String withAnnotations(Map<int, String> annotations) {
+  String withAnnotations(Map<int, List<String>> annotations) {
     StringBuffer sb = new StringBuffer();
     int end = 0;
     for (int offset in annotations.keys.toList()..sort()) {
       if (offset > end) {
         sb.write(code.sourceCode.substring(end, offset));
       }
-      sb.write('/* ');
-      sb.write(annotations[offset]);
-      sb.write(' */');
+      for (String annotation in annotations[offset]) {
+        sb.write('/* ');
+        sb.write(annotation);
+        sb.write(' */');
+      }
       end = offset;
     }
     if (end < code.sourceCode.length) {
       sb.write(code.sourceCode.substring(end));
     }
     return sb.toString();
   }
 
   String get actualCode {
-    Map<int, String> annotations = <int, String>{};
+    Map<int, List<String>> annotations = <int, List<String>>{};
     actualMap.forEach((Id id, ActualData data) {
-      annotations[data.sourceSpan.begin] = data.value;
+      annotations
+          .putIfAbsent(data.sourceSpan.begin, () => [])
+          .add('${data.value}');
     });
     return withAnnotations(annotations);
   }
 
   String get diffCode {
-    Map<int, String> annotations = <int, String>{};
+    Map<int, List<String>> annotations = <int, List<String>>{};
     actualMap.forEach((Id id, ActualData data) {
-      String expected = expectedMap[id] ?? '';
+      String expected = expectedMap[id]?.value ?? '';
       if (data.value != expected) {
-        annotations[data.sourceSpan.begin] = '${expected} | ${data.value}';
+        annotations
+            .putIfAbsent(data.sourceSpan.begin, () => [])
+            .add('${expected} | ${data.value}');
       }
     });
-    expectedMap.forEach((Id id, String expected) {
+    expectedMap.forEach((Id id, IdValue expected) {
       if (!actualMap.containsKey(id)) {
         int offset = compiler.reporter
             .spanFromSpannable(
                 computeSpannable(elementEnvironment, mainUri, id))
             .begin;
-        annotations[offset] = '${expected} | ---';
+        annotations.putIfAbsent(offset, () => []).add('${expected} | ---');
       }
     });
     return withAnnotations(annotations);
   }
 
   String computeDiffCodeFor(IdData other) {
-    Map<int, String> annotations = <int, String>{};
+    Map<int, List<String>> annotations = <int, List<String>>{};
     actualMap.forEach((Id id, ActualData data1) {
       ActualData data2 = other.actualMap[id];
       if (data1.value != data2?.value) {
-        annotations[data1.sourceSpan.begin] =
-            '${data1.value} | ${data2?.value ?? '---'}';
+        annotations
+            .putIfAbsent(data1.sourceSpan.begin, () => [])
+            .add('${data1.value} | ${data2?.value ?? '---'}');
       }
     });
     other.actualMap.forEach((Id id, ActualData data2) {
       if (!actualMap.containsKey(id)) {
         int offset = compiler.reporter
             .spanFromSpannable(
                 computeSpannable(elementEnvironment, mainUri, id))
             .begin;
-        annotations[offset] = '--- | ${data2.value}';
+        annotations.putIfAbsent(offset, () => []).add('--- | ${data2.value}');
       }
     });
     return withAnnotations(annotations);
   }
 }
 
 /// Check code for all test files int [data] using [computeFromAst] and
 /// [computeFromKernel] from the respective front ends. If [skipForKernel]
 /// contains the name of the test file it isn't tested for kernel.
 Future checkTests(Directory dataDir, ComputeMemberDataFunction computeFromAst,
@@ skipping 30 matching lines @@
     String annotatedCode,
     ComputeMemberDataFunction computeMemberData,
     CompileFunction compileFunction,
     {List<String> options: const <String>[],
     bool verbose: false}) async {
   IdData data = await computeData(
       annotatedCode, computeMemberData, compileFunction,
       options: options, verbose: verbose);
 
   data.actualMap.forEach((Id id, ActualData actualData) {
-    String actual = actualData.value;
+    IdValue actual = actualData.value;
     if (!data.expectedMap.containsKey(id)) {
-      if (actual != '') {
+      if (actual.value != '') {
         reportHere(
             data.compiler.reporter,
             actualData.sourceSpan,
             'Id $id = ${actual} for ${actualData.object} '
             '(${actualData.object.runtimeType}) '
             'not expected in ${data.expectedMap.keys}');
         print('--annotations diff--------------------------------------------');
         print(data.diffCode);
         print('--------------------------------------------------------------');
       }
-      Expect.equals('', actual);
+      Expect.equals('', actual.value);
     } else {
-      String expected = data.expectedMap[id];
+      IdValue expected = data.expectedMap[id];
       if (actual != expected) {
         reportHere(
             data.compiler.reporter,
             actualData.sourceSpan,
             'Object: ${actualData.object} (${actualData.object.runtimeType}), '
             'expected: ${expected}, actual: ${actual}');
         print('--annotations diff--------------------------------------------');
         print(data.diffCode);
         print('--------------------------------------------------------------');
       }
       Expect.equals(expected, actual);
     }
   });
 
   Set<Id> missingIds = new Set<Id>();
-  data.expectedMap.forEach((Id id, String expected) {
+  data.expectedMap.forEach((Id id, IdValue expected) {
     if (!data.actualMap.containsKey(id)) {
       missingIds.add(id);
       reportHere(
           data.compiler.reporter,
           computeSpannable(data.elementEnvironment, data.mainUri, id),
           'Expected $expected for id $id missing in ${data.actualMap.keys}');
     }
   });
   Expect.isTrue(missingIds.isEmpty, "Ids not found: ${missingIds}.");
 }
@@ skipping 10 matching lines @@
           elementEnvironment.lookupClass(library, id.className, required: true);
       return elementEnvironment.lookupClassMember(cls, id.memberName);
     } else {
       return elementEnvironment.lookupLibraryMember(library, id.memberName);
     }
   }
   throw new UnsupportedError('Unsupported id $id.');
 }
 
 /// Compute the expectancy map from [code].
-Map<Id, String> computeExpectedMap(AnnotatedCode code) {
-  Map<Id, String> map = <Id, String>{};
+Map<Id, IdValue> computeExpectedMap(AnnotatedCode code) {
+  Map<Id, IdValue> map = <Id, IdValue>{};
   for (Annotation annotation in code.annotations) {
-    String text = annotation.text;
-    int colonPos = text.indexOf(':');
-    Id id;
-    String expected;
-    if (colonPos == -1) {
-      id = new NodeId(annotation.offset);
-      expected = text;
-    } else {
-      id = new ElementId(text.substring(0, colonPos));
-      expected = text.substring(colonPos + 1);
-    }
-    map[id] = expected;
+    IdValue idValue = IdValue.decode(annotation.offset, annotation.text);
+    map[idValue.id] = idValue;
   }
   return map;
 }