dart2js: run dartfmt on tests

tests/compiler/dart2js/sourcemaps/sourcemap_helper.dart

 // Copyright (c) 2015, 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.helper;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:compiler/compiler_new.dart';
 import 'package:compiler/src/apiimpl.dart' as api;
@@ skipping 59 matching lines @@
   @override
   EventSink<String> createEventSink(String name, String extension) {
     return createSourceFileSink(name, extension);
   }
 }
 
 class CloningOutputProvider extends OutputProvider {
   RandomAccessFileOutputProvider outputProvider;
 
   CloningOutputProvider(Uri jsUri, Uri jsMapUri)
-    : outputProvider = new RandomAccessFileOutputProvider(jsUri, jsMapUri);
+      : outputProvider = new RandomAccessFileOutputProvider(jsUri, jsMapUri);
 
   @override
   EventSink<String> createEventSink(String name, String extension) {
     EventSink<String> output = outputProvider(name, extension);
     return new CloningEventSink(
         [output, createSourceFileSink(name, extension)]);
   }
 }
 
 abstract class SourceFileManager {
@@ skipping 16 matching lines @@
   }
 }
 
 class RecordingPrintingContext extends LenientPrintingContext {
   CodePositionListener listener;
   Map<js.Node, CodePosition> codePositions = <js.Node, CodePosition>{};
 
   RecordingPrintingContext(this.listener);
 
   @override
-  void exitNode(js.Node node,
-                int startPosition,
-                int endPosition,
-                int closingPosition) {
+  void exitNode(
+      js.Node node, int startPosition, int endPosition, int closingPosition) {
     codePositions[node] =
         new CodePosition(startPosition, endPosition, closingPosition);
-    listener.onPositions(
-        node, startPosition, endPosition, closingPosition);
+    listener.onPositions(node, startPosition, endPosition, closingPosition);
   }
 }
 
 /// A [SourceMapper] that records the source locations on each node.
 class RecordingSourceMapper implements SourceMapper {
   final SourceMapper sourceMapper;
   final _LocationRecorder nodeToSourceLocationsMap;
 
   RecordingSourceMapper(this.sourceMapper, this.nodeToSourceLocationsMap);
 
   @override
   void register(js.Node node, int codeOffset, SourceLocation sourceLocation) {
     nodeToSourceLocationsMap.register(node, codeOffset, sourceLocation);
     sourceMapper.register(node, codeOffset, sourceLocation);
   }
 }
 
 /// A wrapper of [SourceInformationProcessor] that records source locations and
 /// code positions.
 class RecordingSourceInformationProcessor
     implements SourceInformationProcessor {
   final RecordingSourceInformationStrategy wrapper;
   final SourceInformationProcessor processor;
   final CodePositionRecorder codePositions;
   final LocationMap nodeToSourceLocationsMap;
 
-  RecordingSourceInformationProcessor(
-      this.wrapper,
-      this.processor,
-      this.codePositions,
-      this.nodeToSourceLocationsMap);
+  RecordingSourceInformationProcessor(this.wrapper, this.processor,
+      this.codePositions, this.nodeToSourceLocationsMap);
 
   @override
-  void onPositions(js.Node node,
-                   int startPosition,
-                   int endPosition,
-                   int closingPosition) {
+  void onPositions(
+      js.Node node, int startPosition, int endPosition, int closingPosition) {
     codePositions.registerPositions(
         node, startPosition, endPosition, closingPosition);
     processor.onPositions(node, startPosition, endPosition, closingPosition);
   }
 
   @override
   void process(js.Node node, BufferedCodeOutput code) {
     processor.process(node, code);
     wrapper.registerProcess(
         node, code, codePositions, nodeToSourceLocationsMap);
   }
 }
 
 /// Information recording for a use of [SourceInformationProcessor].
 class RecordedSourceInformationProcess {
   final js.Node root;
   final String code;
   final CodePositionRecorder codePositions;
   final LocationMap nodeToSourceLocationsMap;
 
   RecordedSourceInformationProcess(
-      this.root,
-      this.code,
-      this.codePositions,
-      this.nodeToSourceLocationsMap);
+      this.root, this.code, this.codePositions, this.nodeToSourceLocationsMap);
 }
 
-
 /// A wrapper of [JavaScriptSourceInformationStrategy] that records
 /// [RecordedSourceInformationProcess].
 class RecordingSourceInformationStrategy
     extends JavaScriptSourceInformationStrategy {
   final JavaScriptSourceInformationStrategy strategy;
   final Map<RecordedSourceInformationProcess, js.Node> processMap =
       <RecordedSourceInformationProcess, js.Node>{};
   final Map<js.Node, RecordedSourceInformationProcess> nodeMap =
       <js.Node, RecordedSourceInformationProcess>{};
 
   RecordingSourceInformationStrategy(this.strategy);
 
   @override
   SourceInformationBuilder createBuilderForContext(ResolvedAst resolvedAst) {
     return strategy.createBuilderForContext(resolvedAst);
   }
 
   @override
   SourceInformationProcessor createProcessor(SourceMapper sourceMapper) {
-    LocationMap nodeToSourceLocationsMap =
-        new _LocationRecorder();
+    LocationMap nodeToSourceLocationsMap = new _LocationRecorder();
     CodePositionRecorder codePositions = new CodePositionRecorder();
     return new RecordingSourceInformationProcessor(
         this,
-        strategy.createProcessor(new RecordingSourceMapper(
-            sourceMapper, nodeToSourceLocationsMap)),
-            codePositions, nodeToSourceLocationsMap);
+        strategy.createProcessor(
+            new RecordingSourceMapper(sourceMapper, nodeToSourceLocationsMap)),
+        codePositions,
+        nodeToSourceLocationsMap);
   }
 
-  void registerProcess(js.Node root,
-                       BufferedCodeOutput code,
-                       CodePositionRecorder codePositions,
-                       LocationMap nodeToSourceLocationsMap) {
+  void registerProcess(
+      js.Node root,
+      BufferedCodeOutput code,
+      CodePositionRecorder codePositions,
+      LocationMap nodeToSourceLocationsMap) {
     RecordedSourceInformationProcess subProcess =
         new RecordedSourceInformationProcess(
             root, code.getText(), codePositions, nodeToSourceLocationsMap);
     processMap[subProcess] = root;
   }
 
   RecordedSourceInformationProcess subProcessForNode(js.Node node) {
     return nodeMap.putIfAbsent(node, () {
       for (RecordedSourceInformationProcess subProcess in processMap.keys) {
         js.Node root = processMap[subProcess];
@@ skipping 62 matching lines @@
 
   /// Creates a processor for the Dart file [filename].
   SourceMapProcessor(String filename, {this.outputToFile: false}) {
     inputUri = Uri.base.resolve(nativeToUriPath(filename));
     jsPath = 'out.js';
     targetUri = Uri.base.resolve(jsPath);
     sourceMapFileUri = Uri.base.resolve('${jsPath}.map');
   }
 
   /// Computes the [SourceMapInfo] for the compiled elements.
-  Future<SourceMaps> process(
-      List<String> options,
-      {bool verbose: true,
-       bool perElement: true,
-       bool forMain: false}) async {
+  Future<SourceMaps> process(List<String> options,
+      {bool verbose: true, bool perElement: true, bool forMain: false}) async {
     OutputProvider outputProvider = outputToFile
         ? new CloningOutputProvider(targetUri, sourceMapFileUri)
         : new OutputProvider();
     if (options.contains(Flags.useNewSourceInfo)) {
       if (verbose) print('Using the new source information system.');
     }
     if (options.contains(Flags.disableInlining)) {
       if (verbose) print('Inlining disabled');
     }
     api.CompilerImpl compiler = await compilerFor(
         outputProvider: outputProvider,
         // TODO(johnniwinther): Use [verbose] to avoid showing diagnostics.
         options: ['--out=$targetUri', '--source-map=$sourceMapFileUri']
-            ..addAll(options));
+          ..addAll(options));
 
     JavaScriptBackend backend = compiler.backend;
     var handler = compiler.handler;
     SourceFileProvider sourceFileProvider = handler.provider;
-    sourceFileManager = new ProviderSourceFileManager(
-        sourceFileProvider,
-        outputProvider);
+    sourceFileManager =
+        new ProviderSourceFileManager(sourceFileProvider, outputProvider);
     RecordingSourceInformationStrategy strategy =
-        new RecordingSourceInformationStrategy(backend.sourceInformationStrategy);
+        new RecordingSourceInformationStrategy(
+            backend.sourceInformationStrategy);
     backend.sourceInformationStrategy = strategy;
     await compiler.run(inputUri);
 
     SourceMapInfo mainSourceMapInfo;
     Map<Element, SourceMapInfo> elementSourceMapInfos =
         <Element, SourceMapInfo>{};
     if (perElement) {
       backend.generatedCode.forEach((Element element, js.Expression node) {
         RecordedSourceInformationProcess subProcess =
             strategy.subProcessForNode(node);
         if (subProcess == null) {
           // TODO(johnniwinther): Find out when this is happening and if it
           // is benign. (Known to happen for `bool#fromString`)
           print('No subProcess found for $element');
           return;
         }
         LocationMap nodeMap = subProcess.nodeToSourceLocationsMap;
         String code = subProcess.code;
         CodePositionRecorder codePositions = subProcess.codePositions;
         CodePointComputer visitor =
             new CodePointComputer(sourceFileManager, code, nodeMap);
         new JavaScriptTracer(codePositions, [visitor]).apply(node);
         List<CodePoint> codePoints = visitor.codePoints;
         elementSourceMapInfos[element] = new SourceMapInfo(
-            element,
-            code,
-            node,
-            codePoints,
-            codePositions,
-            nodeMap);
+            element, code, node, codePoints, codePositions, nodeMap);
       });
     }
     if (forMain) {
       // TODO(johnniwinther): Supported multiple output units.
       RecordedSourceInformationProcess process = strategy.processMap.keys.first;
       js.Node node = strategy.processMap[process];
       String code;
       LocationMap nodeMap;
       CodePositionRecorder codePositions;
       nodeMap = process.nodeToSourceLocationsMap;
       code = process.code;
       codePositions = process.codePositions;
       CodePointComputer visitor =
           new CodePointComputer(sourceFileManager, code, nodeMap);
       new JavaScriptTracer(codePositions, [visitor]).apply(node);
       List<CodePoint> codePoints = visitor.codePoints;
       mainSourceMapInfo = new SourceMapInfo(
-          null, code, node,
-          codePoints,
-          codePositions,
-          nodeMap);
+          null, code, node, codePoints, codePositions, nodeMap);
     }
 
     return new SourceMaps(
-        compiler,
-        sourceFileManager,
-        mainSourceMapInfo,
-        elementSourceMapInfos);
+        compiler, sourceFileManager, mainSourceMapInfo, elementSourceMapInfos);
   }
 }
 
 class SourceMaps {
   final api.CompilerImpl compiler;
   final SourceFileManager sourceFileManager;
   // TODO(johnniwinther): Supported multiple output units.
   final SourceMapInfo mainSourceMapInfo;
   final Map<Element, SourceMapInfo> elementSourceMapInfos;
 
-  SourceMaps(
-      this.compiler,
-      this.sourceFileManager,
-      this.mainSourceMapInfo,
-          this.elementSourceMapInfos);
+  SourceMaps(this.compiler, this.sourceFileManager, this.mainSourceMapInfo,
+      this.elementSourceMapInfos);
 }
 
 /// Source mapping information for the JavaScript code of an [Element].
 class SourceMapInfo {
   final String name;
   final Element element;
   final String code;
   final js.Node node;
   final List<CodePoint> codePoints;
   final CodePositionMap jsCodePositions;
   final LocationMap nodeMap;
 
-  SourceMapInfo(
-      Element element,
-      this.code,
-      this.node,
-      this.codePoints,
-      this.jsCodePositions,
-      this.nodeMap)
+  SourceMapInfo(Element element, this.code, this.node, this.codePoints,
+      this.jsCodePositions, this.nodeMap)
       : this.name =
-          element != null ? computeElementNameForSourceMaps(element) : '',
+            element != null ? computeElementNameForSourceMaps(element) : '',
         this.element = element;
 
   String toString() {
     return '$name:$element';
   }
 }
 
 /// Collection of JavaScript nodes with their source mapped target offsets
 /// and source locations.
 abstract class LocationMap {
   Iterable<js.Node> get nodes;
 
-  Map<int, List<SourceLocation>> operator[] (js.Node node);
+  Map<int, List<SourceLocation>> operator [](js.Node node);
 
   factory LocationMap.recorder() = _LocationRecorder;
 
   factory LocationMap.filter(Set<js.Node> nodes, LocationMap map) =
       _FilteredLocationMap;
-
 }
 
-class _LocationRecorder
-    implements SourceMapper, LocationMap {
+class _LocationRecorder implements SourceMapper, LocationMap {
   final Map<js.Node, Map<int, List<SourceLocation>>> _nodeMap = {};
 
   @override
   void register(js.Node node, int codeOffset, SourceLocation sourceLocation) {
-    _nodeMap.putIfAbsent(node, () => {})
+    _nodeMap
+        .putIfAbsent(node, () => {})
         .putIfAbsent(codeOffset, () => [])
         .add(sourceLocation);
   }
 
   Iterable<js.Node> get nodes => _nodeMap.keys;
 
-  Map<int, List<SourceLocation>> operator[] (js.Node node) {
+  Map<int, List<SourceLocation>> operator [](js.Node node) {
     return _nodeMap[node];
   }
 }
 
 class _FilteredLocationMap implements LocationMap {
   final Set<js.Node> _nodes;
   final LocationMap map;
 
   _FilteredLocationMap(this._nodes, this.map);
 
   Iterable<js.Node> get nodes => map.nodes.where((n) => _nodes.contains(n));
 
-  Map<int, List<SourceLocation>> operator[] (js.Node node) {
+  Map<int, List<SourceLocation>> operator [](js.Node node) {
     return map[node];
   }
 }
 
-
 /// Visitor that computes the [CodePoint]s for source mapping locations.
 class CodePointComputer extends TraceListener {
   final SourceFileManager sourceFileManager;
   final String code;
   final LocationMap nodeMap;
   List<CodePoint> codePoints = [];
 
   CodePointComputer(this.sourceFileManager, this.code, this.nodeMap);
 
   String nodeToString(js.Node node) {
@@ skipping 14 matching lines @@
     return line;
   }
 
   /// Called when [node] defines a step of the given [kind] at the given
   /// [offset] when the generated JavaScript code.
   void onStep(js.Node node, Offset offset, StepKind kind) {
     register(kind, node);
   }
 
   void register(StepKind kind, js.Node node, {bool expectInfo: true}) {
-
     String dartCodeFromSourceLocation(SourceLocation sourceLocation) {
       SourceFile sourceFile =
-           sourceFileManager.getSourceFile(sourceLocation.sourceUri);
+          sourceFileManager.getSourceFile(sourceLocation.sourceUri);
       if (sourceFile == null) {
         return sourceLocation.shortText;
       }
-      return sourceFile.getLineText(sourceLocation.line)
-          .substring(sourceLocation.column).trim();
+      return sourceFile
+          .getLineText(sourceLocation.line)
+          .substring(sourceLocation.column)
+          .trim();
     }
 
     void addLocation(SourceLocation sourceLocation, String jsCode) {
       if (sourceLocation == null) {
         if (expectInfo) {
           SourceInformation sourceInformation = node.sourceInformation;
           SourceLocation sourceLocation;
           String dartCode;
           if (sourceInformation != null) {
             sourceLocation = sourceInformation.sourceLocations.first;
             dartCode = dartCodeFromSourceLocation(sourceLocation);
           }
-          codePoints.add(new CodePoint(
-              kind, jsCode, sourceLocation, dartCode, isMissing: true));
+          codePoints.add(new CodePoint(kind, jsCode, sourceLocation, dartCode,
+              isMissing: true));
         }
       } else {
-         codePoints.add(new CodePoint(kind, jsCode, sourceLocation,
-             dartCodeFromSourceLocation(sourceLocation)));
+        codePoints.add(new CodePoint(kind, jsCode, sourceLocation,
+            dartCodeFromSourceLocation(sourceLocation)));
       }
     }
 
     Map<int, List<SourceLocation>> locationMap = nodeMap[node];
     if (locationMap == null) {
       addLocation(null, nodeToString(node));
     } else {
       locationMap.forEach((int targetOffset, List<SourceLocation> locations) {
         String jsCode = nodeToString(node);
         for (SourceLocation location in locations) {
           addLocation(location, jsCode);
         }
       });
     }
   }
 }
 
 /// A JavaScript code point and its mapped dart source location.
 class CodePoint {
   final StepKind kind;
   final String jsCode;
   final SourceLocation sourceLocation;
   final String dartCode;
   final bool isMissing;
 
-  CodePoint(
-      this.kind,
-      this.jsCode,
-      this.sourceLocation,
-      this.dartCode,
+  CodePoint(this.kind, this.jsCode, this.sourceLocation, this.dartCode,
       {this.isMissing: false});
 
   String toString() {
     return 'CodePoint[kind=$kind,js=$jsCode,dart=$dartCode,'
-                     'location=$sourceLocation]';
+        'location=$sourceLocation]';
   }
 }
 
 class IOSourceFileManager implements SourceFileManager {
   final Uri base;
 
   Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
 
   IOSourceFileManager(this.base);
 
   SourceFile getSourceFile(var uri) {
     Uri absoluteUri;
     if (uri is Uri) {
       absoluteUri = base.resolveUri(uri);
     } else {
       absoluteUri = base.resolve(uri);
     }
     return sourceFiles.putIfAbsent(absoluteUri, () {
       String text = new File.fromUri(absoluteUri).readAsStringSync();
       return new StringSourceFile.fromUri(absoluteUri, text);
     });
   }
 }