Add more tested features to closure_test

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 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common_elements.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
@@ skipping 10 matching lines @@
 
 /// Function that compiles [code] with [options] and returns the [Compiler] object.
 typedef Future<Compiler> CompileFunction(
     AnnotatedCode code, Uri mainUri, List<String> options);
 
 /// Function that computes a data mapping for [member].
 ///
 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans
 /// for the data origin.
 typedef void ComputeMemberDataFunction(Compiler compiler, MemberEntity member,
-    Map<Id, String> actualMap, Map<Id, SourceSpan> sourceSpanMap);
+    Map<Id, String> actualMap, Map<Id, SourceSpan> sourceSpanMap,
+    {bool verbose});
 
 /// Compile [code] from .dart sources.
 Future<Compiler> compileFromSource(
     AnnotatedCode code, Uri mainUri, List<String> options) async {
   Compiler compiler = compilerFor(
       memorySourceFiles: {'main.dart': code.sourceCode}, options: options);
   compiler.stopAfterTypeInference = true;
   await compiler.run(mainUri);
   return compiler;
 }
@@ skipping 12 matching lines @@
 }
 
 /// Compute expected and actual data for all members defined in [annotatedCode].
 ///
 /// 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>[]}) async {
+    {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, String> actualMap = <Id, String>{};
   Map<Id, SourceSpan> sourceSpanMap = <Id, SourceSpan>{};
   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, sourceSpanMap);
+        computeMemberData(compiler, member, actualMap, sourceSpanMap,
+            verbose: verbose);
       }
     });
   });
   elementEnvironment.forEachLibraryMember(mainLibrary, (MemberEntity member) {
-    computeMemberData(compiler, member, actualMap, sourceSpanMap);
+    computeMemberData(compiler, member, actualMap, sourceSpanMap,
+        verbose: verbose);
   });
   return new IdData(compiler, elementEnvironment, mainUri, expectedMap,
       actualMap, sourceSpanMap);
 }
 
 /// Data collected by [computeData].
 class IdData {
   final Compiler compiler;
   final ElementEnvironment elementEnvironment;
   final Uri mainUri;
   final Map<Id, String> expectedMap;
   final Map<Id, String> actualMap;
   final Map<Id, SourceSpan> sourceSpanMap;
 
   IdData(this.compiler, this.elementEnvironment, this.mainUri, this.expectedMap,
       this.actualMap, this.sourceSpanMap);
 }
 
 /// Compiles the [annotatedCode] with the provided [options] and calls
 /// [computeMemberData] for each member. The result is checked against the
 /// expected data derived from [annotatedCode].
 Future checkCode(
     String annotatedCode,
     ComputeMemberDataFunction computeMemberData,
     CompileFunction compileFunction,
-    {List<String> options: const <String>[]}) async {
+    {List<String> options: const <String>[],
+    bool verbose: false}) async {
   IdData data = await computeData(
       annotatedCode, computeMemberData, compileFunction,
-      options: options);
+      options: options, verbose: verbose);
 
   data.actualMap.forEach((Id id, String actual) {
-    String expected = data.expectedMap.remove(id);
-    if (actual != expected) {
-      reportHere(data.compiler.reporter, data.sourceSpanMap[id],
-          'expected:${expected},actual:${actual}');
+    if (!data.expectedMap.containsKey(id)) {
+      if (actual != '') {
+        reportHere(data.compiler.reporter, data.sourceSpanMap[id],
+            'Id $id not expected in ${data.expectedMap.keys}');
+      }
+      Expect.equals('', actual);
+    } else {
+      String expected = data.expectedMap.remove(id);
+      if (actual != expected) {
+        reportHere(data.compiler.reporter, data.sourceSpanMap[id],
+            'expected:${expected},actual:${actual}');
+      }
+      Expect.equals(expected, actual);
     }
-    Expect.equals(expected, actual);
   });
 
   data.expectedMap.forEach((Id id, String expected) {
     reportHere(
         data.compiler.reporter,
         computeSpannable(data.elementEnvironment, data.mainUri, id),
         'expected:${expected},actual:null');
   });
   Expect.isTrue(
       data.expectedMap.isEmpty, "Ids not found: ${data.expectedMap}.");
@@ skipping 182 matching lines @@
 
   visitVariableDeclaration(ir.VariableDeclaration node) {
     computeForNode(node);
     super.visitVariableDeclaration(node);
   }
 
   visitFunctionDeclaration(ir.FunctionDeclaration node) {
     computeForNode(node);
     super.visitFunctionDeclaration(node);
   }
+
+  visitFunctionExpression(ir.FunctionExpression node) {
+    computeForNode(node);
+    super.visitFunctionExpression(node);
+  }
 }