dart2js: run dartfmt on tests

tests/compiler/dart2js/sourcemaps/output_structure.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.output_structure;
 
 import 'dart:math' as Math;
-import 'html_parts.dart' show
-    Annotation,
-    CodeLine,
-    JsonStrategy;
+import 'html_parts.dart' show Annotation, CodeLine, JsonStrategy;
 
 // Constants used to identify the subsection of the JavaScript output. These
 // are specifically for the unminified full_emitter output.
 const String HEAD = '  var dart = [';
 const String TAIL = '  }], ';
 const String END = '  setupProgram(dart';
 
 final RegExp TOP_LEVEL_VALUE = new RegExp(r'^    (".+?"):');
 final RegExp TOP_LEVEL_FUNCTION =
     new RegExp(r'^    ([a-zA-Z0-9_$]+): \[?function');
@@ skipping 14 matching lines @@
   Interval get header;
   Interval get footer;
 
   bool get canHaveChildren => false;
 
   List<OutputEntity> get children;
 
   CodeSource codeSource;
 
   Interval getChildInterval(Interval childIndex) {
-    return new Interval(
-        children[childIndex.from].interval.from,
+    return new Interval(children[childIndex.from].interval.from,
         children[childIndex.to - 1].interval.to);
-
   }
 
   OutputEntity getChild(int index) {
     return children[index];
   }
 
   accept(OutputVisitor visitor, arg);
 
   EntityKind get kind;
 
@@ skipping 70 matching lines @@
   }
 }
 
 /// The whole JavaScript output.
 class OutputStructure extends OutputEntity {
   final List<CodeLine> lines;
   final int headerEnd;
   final int footerStart;
   final List<LibraryBlock> children;
 
-  OutputStructure(
-      this.lines,
-      this.headerEnd,
-      this.footerStart,
-      this.children);
+  OutputStructure(this.lines, this.headerEnd, this.footerStart, this.children);
 
   @override
   EntityKind get kind => EntityKind.STRUCTURE;
 
   Interval get interval => new Interval(0, lines.length);
 
   Interval get header => new Interval(0, headerEnd);
 
   Interval get footer => new Interval(footerStart, lines.length);
 
   bool get canHaveChildren => true;
 
   OutputEntity getEntityForLine(int line) {
     if (line < headerEnd || line >= footerStart) {
       return this;
     }
     for (LibraryBlock library in children) {
       if (library.interval.contains(line)) {
         return library.getEntityForLine(line);
       }
     }
     return null;
   }
 
   /// Compute the structure of the JavaScript [lines].
   static OutputStructure parse(List<CodeLine> lines) {
-
     int findHeaderStart(List<CodeLine> lines) {
       int index = 0;
       for (CodeLine line in lines) {
         if (line.code.startsWith(HEAD)) {
           return index;
         }
         index++;
       }
       return lines.length;
     }
@@ skipping 40 matching lines @@
     }
 
     int headerEnd = findHeaderStart(lines);
     int footerStart = findHeaderEnd(headerEnd, lines);
     List<LibraryBlock> libraryBlocks =
         computeHeaderMap(lines, headerEnd, footerStart);
     for (LibraryBlock block in libraryBlocks) {
       block.preprocess(lines);
     }
 
-    return new OutputStructure(
-        lines, headerEnd, footerStart, libraryBlocks);
+    return new OutputStructure(lines, headerEnd, footerStart, libraryBlocks);
   }
 
   accept(OutputVisitor visitor, arg) => visitor.visitStructure(this, arg);
 
   @override
   Map toJson(JsonStrategy strategy) {
     return {
       'lines': lines.map((line) => line.toJson(strategy)).toList(),
       'headerEnd': headerEnd,
       'footerStart': footerStart,
       'children': children.map((child) => child.toJson(strategy)).toList(),
     };
   }
 
   static OutputStructure fromJson(Map json, JsonStrategy strategy) {
     List<CodeLine> lines =
         json['lines'].map((l) => CodeLine.fromJson(l, strategy)).toList();
     int headerEnd = json['headerEnd'];
     int footerStart = json['footerStart'];
-    List<LibraryBlock> children =
-        json['children']
-            .map((j) => AbstractEntity.fromJson(j, strategy))
-            .toList();
+    List<LibraryBlock> children = json['children']
+        .map((j) => AbstractEntity.fromJson(j, strategy))
+        .toList();
     return new OutputStructure(lines, headerEnd, footerStart, children);
   }
 }
 
 abstract class AbstractEntity extends OutputEntity {
   final String name;
   final int from;
   int to;
 
   AbstractEntity(this.name, this.from);
@@ skipping 24 matching lines @@
         throw new StateError('Unexpected entity kind $kind');
       case EntityKind.LIBRARY:
         LibraryBlock lib = new LibraryBlock(name, from)
           ..to = to
           ..codeSource = codeSource;
         json['children']
             .forEach((child) => lib.children.add(fromJson(child, strategy)));
         return lib;
       case EntityKind.CLASS:
         LibraryClass cls = new LibraryClass(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
         json['children']
             .forEach((child) => cls.children.add(fromJson(child, strategy)));
         return cls;
       case EntityKind.TOP_LEVEL_FUNCTION:
         return new TopLevelFunction(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
       case EntityKind.TOP_LEVEL_VALUE:
         return new TopLevelValue(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
       case EntityKind.MEMBER_FUNCTION:
         return new MemberFunction(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
       case EntityKind.MEMBER_OBJECT:
         return new MemberObject(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
       case EntityKind.MEMBER_VALUE:
         return new MemberValue(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
       case EntityKind.STATICS:
         Statics statics = new Statics(from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
         json['children'].forEach(
             (child) => statics.children.add(fromJson(child, strategy)));
         return statics;
       case EntityKind.STATIC_FUNCTION:
         return new StaticFunction(name, from)
-            ..to = to
-            ..codeSource = codeSource;
+          ..to = to
+          ..codeSource = codeSource;
     }
   }
 }
 
 /// A block defining the content of a Dart library.
 class LibraryBlock extends AbstractEntity {
   List<BasicEntity> children = <BasicEntity>[];
   int get headerEnd => from + 2;
-  int get footerStart => to/* - 1*/;
+  int get footerStart => to /* - 1*/;
 
   LibraryBlock(String name, int from) : super(name, from);
 
   @override
   EntityKind get kind => EntityKind.LIBRARY;
 
   Interval get header => new Interval(from, headerEnd);
 
   Interval get footer => new Interval(footerStart, to);
 
@@ skipping 286 matching lines @@
     return new Interval(Math.min(from, index), Math.max(to, index + 1));
   }
 
   bool inWindow(int index, {int windowSize: 0}) {
     return from - windowSize <= index && index < to + windowSize;
   }
 
   String toString() => '[$from,$to[';
 }
 
-enum CodeKind {
-  LIBRARY,
-  CLASS,
-  MEMBER,
-}
+enum CodeKind { LIBRARY, CLASS, MEMBER, }
 
 class CodeLocation {
   final Uri uri;
   final String name;
   final int offset;
 
   CodeLocation(this.uri, this.name, this.offset);
 
   String toString() => '$uri:$name:$offset';
 
   Map toJson(JsonStrategy strategy) {
-    return {
-      'uri': uri.toString(),
-      'name': name,
-      'offset': offset,
-    };
+    return {'uri': uri.toString(), 'name': name, 'offset': offset,};
   }
 
   static CodeLocation fromJson(Map json, JsonStrategy strategy) {
     if (json == null) return null;
     return new CodeLocation(
-        Uri.parse(json['uri']),
-        json['name'],
-        json['offset']);
+        Uri.parse(json['uri']), json['name'], json['offset']);
   }
 }
 
 /// A named entity in source code. This is used to serialize [Element]
 /// references without serializing the [Element] itself.
 class CodeSource {
   final CodeKind kind;
   final Uri uri;
   final String name;
   final int begin;
   final int end;
   final List<CodeSource> members = <CodeSource>[];
 
   CodeSource(this.kind, this.uri, this.name, this.begin, this.end);
 
   int get hashCode {
-    return
-        kind.hashCode * 13 +
+    return kind.hashCode * 13 +
         uri.hashCode * 17 +
         name.hashCode * 19 +
         begin.hashCode * 23;
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! CodeSource) return false;
-    return
-        kind == other.kind &&
+    return kind == other.kind &&
         uri == other.uri &&
         name == other.name &&
         begin == other.begin;
-
   }
 
   String toString() => '${toJson()}';
 
   Map toJson() {
     return {
       'kind': kind.index,
       'uri': uri.toString(),
       'name': name,
       'begin': begin,
       'end': end,
       'members': members.map((c) => c.toJson()).toList(),
     };
   }
 
   static CodeSource fromJson(Map json) {
     if (json == null) return null;
-    CodeSource codeSource = new CodeSource(
-        CodeKind.values[json['kind']],
-        Uri.parse(json['uri']),
-        json['name'],
-        json['begin'],
-        json['end']);
+    CodeSource codeSource = new CodeSource(CodeKind.values[json['kind']],
+        Uri.parse(json['uri']), json['name'], json['begin'], json['end']);
     json['members'].forEach((m) => codeSource.members.add(fromJson(m)));
     return codeSource;
   }
-}
+}