dart2js: run dartfmt on tests

tests/compiler/dart2js/sourcemaps/diff_view.dart

 // Copyright (c) 2016, 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.
 
 library sourcemap.diff_view;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 72 matching lines @@
   }
 
   SourceFileManager sourceFileManager = new IOSourceFileManager(Uri.base);
   List<AnnotatedOutput> outputs = <AnnotatedOutput>[];
   for (int i = 0; i < 2; i++) {
     AnnotatedOutput output;
     if (loadFrom.containsKey(i)) {
       output = AnnotatedOutput.loadOutput(loadFrom[i]);
     } else {
       print('Compiling ${options[i].join(' ')} $filename');
-      CodeLinesResult result = await computeCodeLines(
-          options[i], filename);
+      CodeLinesResult result = await computeCodeLines(options[i], filename);
       OutputStructure structure = OutputStructure.parse(result.codeLines);
       computeEntityCodeSources(result, structure);
       output = new AnnotatedOutput(
-          filename,
-          options[i],
-          structure,
-          result.coverage.getCoverageReport());
+          filename, options[i], structure, result.coverage.getCoverageReport());
     }
     if (saveTo.containsKey(i)) {
       AnnotatedOutput.saveOutput(output, saveTo[i]);
     }
     outputs.add(output);
   }
 
   List<DiffBlock> blocks = createDiffBlocks(
-      outputs.map((o) => o.structure).toList(),
-      sourceFileManager);
+      outputs.map((o) => o.structure).toList(), sourceFileManager);
 
-  outputDiffView(
-      out, outputs, blocks,
-      showMarkers: showAnnotations,
-      showSourceMapped: showAnnotations);
+  outputDiffView(out, outputs, blocks,
+      showMarkers: showAnnotations, showSourceMapped: showAnnotations);
 }
 
 /// Attaches [CodeSource]s to the entities in [structure] using the
 /// element-to-offset in [result].
 void computeEntityCodeSources(
     CodeLinesResult result, OutputStructure structure) {
   result.elementMap.forEach((int line, Element element) {
     OutputEntity entity = structure.getEntityForLine(line);
     if (entity != null) {
       entity.codeSource = codeSourceFromElement(element);
     }
   });
 }
 
 class CodeLineAnnotationJsonStrategy implements JsonStrategy {
   const CodeLineAnnotationJsonStrategy();
 
   Map encodeAnnotation(Annotation annotation) {
     CodeLineAnnotation data = annotation.data;
     return {
       'id': annotation.id,
       'codeOffset': annotation.codeOffset,
       'title': annotation.title,
       'data': data.toJson(this),
     };
   }
 
   Annotation decodeAnnotation(Map json) {
-    return new Annotation(
-        json['id'],
-        json['codeOffset'],
-        json['title'],
+    return new Annotation(json['id'], json['codeOffset'], json['title'],
         data: CodeLineAnnotation.fromJson(json['data'], this));
   }
 
   @override
   decodeLineAnnotation(json) {
     if (json != null) {
       return CodeSource.fromJson(json);
     }
     return null;
   }
@@ skipping 30 matching lines @@
   static AnnotatedOutput fromJson(Map json) {
     String filename = json['filename'];
     List<String> options = json['options'];
     OutputStructure structure = OutputStructure.fromJson(
         json['structure'], const CodeLineAnnotationJsonStrategy());
     String coverage = json['coverage'];
     return new AnnotatedOutput(filename, options, structure, coverage);
   }
 
   static AnnotatedOutput loadOutput(filename) {
-    AnnotatedOutput output = AnnotatedOutput.fromJson(
-        JSON.decode(new File(filename).readAsStringSync()));
+    AnnotatedOutput output = AnnotatedOutput
+        .fromJson(JSON.decode(new File(filename).readAsStringSync()));
     print('Output loaded from $filename');
     return output;
   }
 
   static void saveOutput(AnnotatedOutput output, String filename) {
     if (filename != null) {
       new File(filename).writeAsStringSync(
           const JsonEncoder.withIndent('  ').convert(output.toJson()));
       print('Output saved in $filename');
     }
   }
 }
 
 void outputDiffView(
-    String out,
-    List<AnnotatedOutput> outputs,
-    List<DiffBlock> blocks,
-    {bool showMarkers: true,
-     bool showSourceMapped: true}) {
+    String out, List<AnnotatedOutput> outputs, List<DiffBlock> blocks,
+    {bool showMarkers: true, bool showSourceMapped: true}) {
   assert(outputs[0].filename == outputs[1].filename);
   bool usePre = true;
 
   StringBuffer sb = new StringBuffer();
   sb.write('''
 <html>
 <head>
 <title>Diff for ${outputs[0].filename}</title>
 <style>
 .${ClassNames.lineNumber} {
@@ skipping 242 matching lines @@
     sb.write('''
 <span class="${ClassNames.sourceMappingIndex(i)}">&nbsp;&nbsp;</span>''');
   }
   sb.write('''
   <span title="JavaScript offsets and their corresponding Dart Code offset 
 as mapped through source-maps.">
   mapped source locations</span>
   </span>
 ''');
 
-
   /// Marker to alternate output colors.
   bool alternating = false;
 
   List<HtmlPrintContext> printContexts = <HtmlPrintContext>[];
   for (int i = 0; i < 2; i++) {
     int lineNoWidth;
     if (outputs[i].codeLines.isNotEmpty) {
       lineNoWidth = '${outputs[i].codeLines.last.lineNo + 1}'.length;
     }
     printContexts.add(new HtmlPrintContext(
         lineNoWidth: lineNoWidth,
         getAnnotationData: getAnnotationData,
         getLineData: getLineData));
   }
 
   Set<DiffColumn> allColumns = new Set<DiffColumn>();
   for (DiffBlock block in blocks) {
     allColumns.addAll(block.columns);
   }
 
   List<DiffColumn> columns = [column_js0, column_js1, column_dart]
-      .where((c) => allColumns.contains(c)).toList();
+      .where((c) => allColumns.contains(c))
+      .toList();
 
   sb.write('''
 </div>
 <table class="${ClassNames.headerTable}"><tr>''');
   for (DiffColumn column in columns) {
     sb.write('''
 <td class="${ClassNames.headerColumn} ${ClassNames.column(column)}">''');
     if (column.type == 'js') {
       sb.write('''[${outputs[column.index].options.join(',')}]''');
     } else {
@@ skipping 13 matching lines @@
     switch (block.kind) {
       case DiffKind.UNMATCHED:
         className = '${ClassNames.cell}';
         break;
       case DiffKind.MATCHING:
         className =
             '${ClassNames.cell} ${ClassNames.corresponding(alternating)}';
         alternating = !alternating;
         break;
       case DiffKind.IDENTICAL:
-        className =
-            '${ClassNames.cell} ${ClassNames.identical(alternating)}';
+        className = '${ClassNames.cell} ${ClassNames.identical(alternating)}';
         alternating = !alternating;
         break;
     }
     sb.write('<tr>');
     for (DiffColumn column in columns) {
       sb.write('''<td class="$className ${ClassNames.column(column)}">''');
       HtmlPrintContext context = new HtmlPrintContext(
           lineNoWidth: 4,
           includeAnnotation: (Annotation annotation) {
             CodeLineAnnotation data = annotation.data;
             return data.annotationType == AnnotationType.WITH_SOURCE_INFO ||
-                   data.annotationType == AnnotationType.ADDITIONAL_SOURCE_INFO;
+                data.annotationType == AnnotationType.ADDITIONAL_SOURCE_INFO;
           },
           getAnnotationData: getAnnotationData,
           getLineData: getLineData);
       if (column.type == 'js') {
         context = printContexts[column.index];
       }
       block.printHtmlOn(column, sb, context);
       sb.write('''</td>''');
     }
     sb.write('</tr>');
@@ skipping 54 matching lines @@
   print('Diff generated in $out');
 }
 
 class CodeLinesResult {
   final List<CodeLine> codeLines;
   final Coverage coverage;
   final Map<int, Element> elementMap;
   final SourceFileManager sourceFileManager;
   final CodeSources codeSources;
 
-  CodeLinesResult(
-      this.codeLines,
-      this.coverage,
-      this.elementMap,
-      this.sourceFileManager,
-      this.codeSources);
+  CodeLinesResult(this.codeLines, this.coverage, this.elementMap,
+      this.sourceFileManager, this.codeSources);
 }
 
 class CodeSources {
   Map<Element, CodeSource> codeSourceMap = <Element, CodeSource>{};
   Map<Uri, Map<Interval, CodeSource>> uriCodeSourceMap =
       <Uri, Map<Interval, CodeSource>>{};
 
-  CodeSources(
-    SourceMapProcessor processor,
-    SourceMaps sourceMaps) {
-
+  CodeSources(SourceMapProcessor processor, SourceMaps sourceMaps) {
     CodeSource computeCodeSource(Element element) {
       return codeSourceMap.putIfAbsent(element, () {
         CodeSource codeSource = codeSourceFromElement(element);
         if (codeSource.begin != null) {
           Interval interval = new Interval(codeSource.begin, codeSource.end);
           Map<Interval, CodeSource> intervals =
               uriCodeSourceMap[codeSource.uri];
           if (intervals == null) {
             intervals = <Interval, CodeSource>{};
             uriCodeSourceMap[codeSource.uri] = intervals;
           } else {
             for (Interval existingInterval in intervals.keys.toList()) {
               if (existingInterval.contains(interval.from)) {
                 CodeSource existingCodeSource = intervals[existingInterval];
                 intervals.remove(existingInterval);
                 if (existingInterval.from < interval.from) {
-                  Interval preInterval = new Interval(
-                      existingInterval.from, interval.from);
+                  Interval preInterval =
+                      new Interval(existingInterval.from, interval.from);
                   intervals[preInterval] = existingCodeSource;
                 }
                 if (interval.to < existingInterval.to) {
-                  Interval postInterval = new Interval(
-                      interval.to, existingInterval.to);
+                  Interval postInterval =
+                      new Interval(interval.to, existingInterval.to);
                   intervals[postInterval] = existingCodeSource;
                 }
               }
             }
           }
           intervals[interval] = codeSource;
         }
         if (element is ClassElement) {
           element.forEachLocalMember((Element member) {
             codeSource.members.add(computeCodeSource(member));
           });
           element.implementation.forEachLocalMember((Element member) {
             codeSource.members.add(computeCodeSource(member));
           });
         } else if (element is MemberElement) {
           element.nestedClosures.forEach((Element closure) {
             codeSource.members.add(computeCodeSource(closure));
           });
         }
         return codeSource;
       });
     }
 
-    for (LibraryElement library in
-             sourceMaps.compiler.libraryLoader.libraries) {
+    for (LibraryElement library
+        in sourceMaps.compiler.libraryLoader.libraries) {
       library.forEachLocalMember(computeCodeSource);
       library.implementation.forEachLocalMember(computeCodeSource);
     }
 
     uriCodeSourceMap.forEach((Uri uri, Map<Interval, CodeSource> intervals) {
-      List<Interval> sortedKeys = intervals.keys.toList()..sort(
-          (i1, i2) => i1.from.compareTo(i2.from));
+      List<Interval> sortedKeys = intervals.keys.toList()
+        ..sort((i1, i2) => i1.from.compareTo(i2.from));
       Map<Interval, CodeSource> sortedintervals = <Interval, CodeSource>{};
       sortedKeys.forEach((Interval interval) {
         sortedintervals[interval] = intervals[interval];
       });
       uriCodeSourceMap[uri] = sortedintervals;
     });
   }
 
   CodeSource sourceLocationToCodeSource(SourceLocation sourceLocation) {
     Map<Interval, CodeSource> intervals =
         uriCodeSourceMap[sourceLocation.sourceUri];
     if (intervals == null) {
       print('No code source for $sourceLocation(${sourceLocation.offset})');
       print(' -- no intervals for ${sourceLocation.sourceUri}');
       return null;
     }
     for (Interval interval in intervals.keys) {
       if (interval.contains(sourceLocation.offset)) {
         return intervals[interval];
       }
     }
     print('No code source for $sourceLocation(${sourceLocation.offset})');
     intervals.forEach((k, v) => print(' $k: ${v.name}'));
     return null;
   }
 }
 
 /// Compute [CodeLine]s and [Coverage] for [filename] using the given [options].
 Future<CodeLinesResult> computeCodeLines(
-    List<String> options,
-    String filename) async {
+    List<String> options, String filename) async {
   SourceMapProcessor processor = new SourceMapProcessor(filename);
   SourceMaps sourceMaps =
       await processor.process(options, perElement: true, forMain: true);
 
   CodeSources codeSources = new CodeSources(processor, sourceMaps);
 
   SourceMapInfo info = sourceMaps.mainSourceMapInfo;
 
   int nextAnnotationId = 0;
   List<CodeLine> codeLines;
   Coverage coverage = new Coverage();
   Map<int, List<CodeLineAnnotation>> codeLineAnnotationMap =
       <int, List<CodeLineAnnotation>>{};
 
   /// Create a [CodeLineAnnotation] for [codeOffset].
   void addCodeLineAnnotation(
       {AnnotationType annotationType,
-       int codeOffset,
-       List<SourceLocation> locations: const <SourceLocation>[],
-       String stepInfo}) {
+      int codeOffset,
+      List<SourceLocation> locations: const <SourceLocation>[],
+      String stepInfo}) {
     if (annotationType == AnnotationType.WITHOUT_SOURCE_INFO ||
         annotationType == AnnotationType.UNUSED_SOURCE_INFO) {
       locations = [];
     }
     List<CodeLocation> codeLocations = locations
         .map((l) => new CodeLocation(l.sourceUri, l.sourceName, l.offset))
         .toList();
     List<CodeSource> codeSourceList = locations
         .map(codeSources.sourceLocationToCodeSource)
         .where((c) => c != null)
         .toList();
     CodeLineAnnotation data = new CodeLineAnnotation(
         annotationId: nextAnnotationId++,
         annotationType: annotationType,
         codeLocations: codeLocations,
         codeSources: codeSourceList,
         stepInfo: stepInfo);
-    codeLineAnnotationMap.putIfAbsent(
-        codeOffset, () => <CodeLineAnnotation>[]).add(data);
+    codeLineAnnotationMap
+        .putIfAbsent(codeOffset, () => <CodeLineAnnotation>[])
+        .add(data);
   }
 
   String code = info.code;
   TraceGraph graph = createTraceGraph(info, coverage);
 
   Set<js.Node> mappedNodes = new Set<js.Node>();
 
   /// Add an annotation for [codeOffset] pointing to [locations].
   void addSourceLocations(
       {AnnotationType annotationType,
-       int codeOffset,
-       List<SourceLocation> locations,
-       String stepInfo}) {
+      int codeOffset,
+      List<SourceLocation> locations,
+      String stepInfo}) {
     locations = locations.where((l) => l != null).toList();
     addCodeLineAnnotation(
         annotationType: annotationType,
         codeOffset: codeOffset,
         stepInfo: stepInfo,
         locations: locations);
   }
 
   /// Add annotations for all mappings created for [node].
   bool addSourceLocationsForNode(
-      {AnnotationType annotationType,
-       js.Node node,
-       String stepInfo}) {
+      {AnnotationType annotationType, js.Node node, String stepInfo}) {
     Map<int, List<SourceLocation>> locations = info.nodeMap[node];
     if (locations == null || locations.isEmpty) {
       return false;
     }
     locations.forEach((int offset, List<SourceLocation> locations) {
       addSourceLocations(
           annotationType: annotationType,
           codeOffset: offset,
           locations: locations,
           stepInfo: stepInfo);
@@ skipping 22 matching lines @@
             codeOffset: offset,
             stepInfo: stepInfo);
       }
     }
   }
 
   // Add additional annotations for mappings created for particular nodes.
   for (js.Node node in info.nodeMap.nodes) {
     if (!mappedNodes.contains(node)) {
       addSourceLocationsForNode(
-          annotationType: AnnotationType.ADDITIONAL_SOURCE_INFO,
-          node: node);
+          annotationType: AnnotationType.ADDITIONAL_SOURCE_INFO, node: node);
     }
   }
 
   // Add annotations for unused source information associated with nodes.
   SourceLocationCollector collector = new SourceLocationCollector();
   info.node.accept(collector);
-  collector.sourceLocations.forEach(
-      (js.Node node, List<SourceLocation> locations) {
+  collector.sourceLocations
+      .forEach((js.Node node, List<SourceLocation> locations) {
     if (!mappedNodes.contains(node)) {
       int offset = info.jsCodePositions[node].startPosition;
       addSourceLocations(
-        annotationType: AnnotationType.UNUSED_SOURCE_INFO,
-        codeOffset: offset,
-        locations: locations);
+          annotationType: AnnotationType.UNUSED_SOURCE_INFO,
+          codeOffset: offset,
+          locations: locations);
     }
   });
 
   // Assign consecutive ids to source mappings.
   int nextSourceMappedLocationIndex = 0;
   List<Annotation> annotations = <Annotation>[];
   for (int codeOffset in codeLineAnnotationMap.keys.toList()..sort()) {
     bool hasSourceMappedLocation = false;
     for (CodeLineAnnotation data in codeLineAnnotationMap[codeOffset]) {
       if (data.annotationType.isSourceMapped) {
         data.sourceMappingIndex = nextSourceMappedLocationIndex;
         hasSourceMappedLocation = true;
       }
       annotations.add(new Annotation(
-          data.annotationType.index,
-          codeOffset,
-          'id=${data.annotationId}',
+          data.annotationType.index, codeOffset, 'id=${data.annotationId}',
           data: data));
     }
     if (hasSourceMappedLocation) {
       nextSourceMappedLocationIndex++;
     }
   }
 
   // Associate JavaScript offsets with [Element]s.
   StringSourceFile sourceFile = new StringSourceFile.fromName(filename, code);
   Map<int, Element> elementMap = <int, Element>{};
-  sourceMaps.elementSourceMapInfos.forEach(
-      (Element element, SourceMapInfo info) {
+  sourceMaps.elementSourceMapInfos
+      .forEach((Element element, SourceMapInfo info) {
     CodePosition position = info.jsCodePositions[info.node];
     elementMap[sourceFile.getLine(position.startPosition)] = element;
   });
 
   codeLines = convertAnnotatedCodeToCodeLines(code, annotations);
-  return new CodeLinesResult(
-      codeLines, coverage, elementMap,
-      sourceMaps.sourceFileManager,
-      codeSources);
+  return new CodeLinesResult(codeLines, coverage, elementMap,
+      sourceMaps.sourceFileManager, codeSources);
 }
 
 /// Visitor that computes a map from [js.Node]s to all attached source
 /// locations.
 class SourceLocationCollector extends js.BaseVisitor {
   Map<js.Node, List<SourceLocation>> sourceLocations =
       <js.Node, List<SourceLocation>>{};
 
   @override
   visitNode(js.Node node) {
@@ skipping 33 matching lines @@
   }
   return new CodeSource(kind, uri, name, begin, end);
 }
 
 /// Create [LineData] that colors line numbers according to the [CodeSource]s
 /// origin if available.
 LineData getLineData(CodeSource lineAnnotation) {
   if (lineAnnotation != null) {
     return new LineData(
         lineClass: ClassNames.line,
-        lineNumberClass:
-          '${ClassNames.lineNumber} '
-          '${ClassNames.colored(lineAnnotation.hashCode % 4)}');
+        lineNumberClass: '${ClassNames.lineNumber} '
+            '${ClassNames.colored(lineAnnotation.hashCode % 4)}');
   }
   return new LineData(
-      lineClass: ClassNames.line,
-      lineNumberClass: ClassNames.lineNumber);
+      lineClass: ClassNames.line, lineNumberClass: ClassNames.lineNumber);
 }
 
 AnnotationData getAnnotationData(Iterable<Annotation> annotations,
-                                 {bool forSpan}) {
+    {bool forSpan}) {
   for (Annotation annotation in annotations) {
     CodeLineAnnotation data = annotation.data;
     if (data.annotationType.isSourceMapped) {
       if (forSpan) {
         int index = data.sourceMappingIndex;
-        return new AnnotationData(
-            tag: 'span',
-            properties: {
-              'class':
-                '${ClassNames.sourceMapping} '
-                '${ClassNames.sourceMappingIndex(index % HUE_COUNT)}',
-              'title': 'index=$index',
-            });
+        return new AnnotationData(tag: 'span', properties: {
+          'class': '${ClassNames.sourceMapping} '
+              '${ClassNames.sourceMappingIndex(index % HUE_COUNT)}',
+          'title': 'index=$index',
+        });
       } else {
-        return new AnnotationData(
-            tag: 'span',
-            properties: {
-              'title': annotation.title,
-              'class': '${ClassNames.marker} '
-                       '${data.annotationType.className}'});
+        return new AnnotationData(tag: 'span', properties: {
+          'title': annotation.title,
+          'class': '${ClassNames.marker} '
+              '${data.annotationType.className}'
+        });
       }
     }
   }
   if (forSpan) return null;
   for (Annotation annotation in annotations) {
     CodeLineAnnotation data = annotation.data;
     if (data.annotationType == AnnotationType.UNUSED_SOURCE_INFO) {
-      return new AnnotationData(
-          tag: 'span',
-          properties: {
-            'title': annotation.title,
-            'class': '${ClassNames.marker} '
-                     '${data.annotationType.className}'});
+      return new AnnotationData(tag: 'span', properties: {
+        'title': annotation.title,
+        'class': '${ClassNames.marker} '
+            '${data.annotationType.className}'
+      });
     }
   }
   for (Annotation annotation in annotations) {
     CodeLineAnnotation data = annotation.data;
     if (data.annotationType == AnnotationType.WITHOUT_SOURCE_INFO) {
-      return new AnnotationData(
-          tag: 'span',
-          properties: {
-            'title': annotation.title,
-            'class': '${ClassNames.marker} '
-                     '${data.annotationType.className}'});
+      return new AnnotationData(tag: 'span', properties: {
+        'title': annotation.title,
+        'class': '${ClassNames.marker} '
+            '${data.annotationType.className}'
+      });
     }
   }
   return null;
 }