Add more info to closure_test output

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/common.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
@@ skipping 30 matching lines @@
       await checkCode(annotatedCode, computeKernelClosureData, compileFromDill,
           verbose: verbose);
     }
   });
 }
 
 /// Compute closure data mapping for [_member] as a [MemberElement].
 ///
 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans
 /// for the data origin.
-void computeClosureData(Compiler compiler, MemberEntity _member,
-    Map<Id, String> actualMap, Map<Id, SourceSpan> sourceSpanMap,
+void computeClosureData(
+    Compiler compiler, MemberEntity _member, Map<Id, ActualData> actualMap,
     {bool verbose: false}) {
   MemberElement member = _member;
   ClosureDataLookup<ast.Node> closureDataLookup =
       compiler.backendStrategy.closureDataLookup as ClosureDataLookup<ast.Node>;
-  new ClosureAstComputer(compiler.reporter, actualMap, sourceSpanMap,
-          member.resolvedAst, closureDataLookup,
+  new ClosureAstComputer(
+          compiler.reporter, actualMap, member.resolvedAst, closureDataLookup,
           verbose: verbose)
       .run();
 }
 
 /// Compute closure data mapping for [member] as a kernel based element.
 ///
 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans
 /// for the data origin.
-void computeKernelClosureData(Compiler compiler, MemberEntity member,
-    Map<Id, String> actualMap, Map<Id, SourceSpan> sourceSpanMap,
+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, sourceSpanMap, elementMap, member,
+  new ClosureIrChecker(actualMap, elementMap, member,
           localsMap.getLocalsMap(member), closureDataLookup,
           verbose: verbose)
       .run(definition.node);
 }
 
 /// Ast visitor for computing closure data.
 class ClosureAstComputer extends AbstractResolvedAstComputer
     with ComputeValueMixin {
   final ClosureDataLookup<ast.Node> closureDataLookup;
   final bool verbose;
 
-  ClosureAstComputer(
-      DiagnosticReporter reporter,
-      Map<Id, String> actualMap,
-      Map<Id, Spannable> spannableMap,
-      ResolvedAst resolvedAst,
-      this.closureDataLookup,
+  ClosureAstComputer(DiagnosticReporter reporter, Map<Id, ActualData> actualMap,
+      ResolvedAst resolvedAst, this.closureDataLookup,
       {this.verbose: false})
-      : super(reporter, actualMap, spannableMap, resolvedAst) {
+      : super(reporter, actualMap, resolvedAst) {
     push(resolvedAst.element);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     Entity localFunction = resolvedAst.elements.getFunctionDefinition(node);
     if (localFunction is LocalFunctionElement) {
       push(localFunction);
       super.visitFunctionExpression(node);
       pop();
     } else {
@@ skipping 24 matching lines @@
 }
 
 /// Kernel IR visitor for computing closure data.
 class ClosureIrChecker extends AbstractIrComputer
     with ComputeValueMixin<ir.Node> {
   final ClosureDataLookup<ir.Node> closureDataLookup;
   final KernelToLocalsMap _localsMap;
   final bool verbose;
 
   ClosureIrChecker(
-      Map<Id, String> actualMap,
-      Map<Id, SourceSpan> sourceSpanMap,
+      Map<Id, ActualData> actualMap,
       KernelToElementMapForBuilding elementMap,
       MemberEntity member,
       this._localsMap,
       this.closureDataLookup,
       {this.verbose: false})
-      : super(actualMap, sourceSpanMap) {
+      : super(actualMap) {
     push(member);
   }
 
   visitFunctionExpression(ir.FunctionExpression node) {
     Local localFunction = _localsMap.getLocalFunction(node);
     push(localFunction);
     super.visitFunctionExpression(node);
     pop();
   }
 
@@ skipping 158 matching lines @@
         if (value != '') {
           sb.write('=');
           sb.write(value);
         }
         needsComma = true;
       }
     }
     return sb.toString();
   }
 }