Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/private/js_array.dart

 // Copyright (c) 2012, 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.
 
 part of dart._interceptors;
 
 /**
  * The interceptor class for [List]. The compiler recognizes this
  * class as an interceptor, and changes references to [:this:] to
  * actually use the receiver of the method, which is generated as an extra
  * argument added to each member.
  */
 @JsPeerInterface(name: 'Array')
 class JSArray<E> implements List<E>, JSIndexable<E> {
-
   const JSArray();
 
   /**
    * Constructor for adding type parameters to an existing JavaScript Array.
    */
   factory JSArray.typed(allocation) =>
       // TODO(jmesserly): skip this when E is dynamic and Object.
       JS('-dynamic', 'dart.list(#, #)', allocation, E);
 
   /**
@@ skipping 41 matching lines @@
     }
   }
 
   void add(E value) {
     checkGrowable('add');
     JS('void', r'#.push(#)', this, value);
   }
 
   E removeAt(int index) {
     checkGrowable('removeAt');
-    if (index is !int) throw argumentErrorValue(index);
+    if (index is! int) throw argumentErrorValue(index);
     if (index < 0 || index >= length) {
       throw new RangeError.value(index);
     }
     return JS('-dynamic', r'#.splice(#, 1)[0]', this, index);
   }
 
   void insert(int index, E value) {
     checkGrowable('insert');
-    if (index is !int) throw argumentErrorValue(index);
+    if (index is! int) throw argumentErrorValue(index);
     if (index < 0 || index > length) {
       throw new RangeError.value(index);
     }
     JS('void', r'#.splice(#, 0, #)', this, index, value);
   }
 
   void insertAll(int index, Iterable<E> iterable) {
     checkGrowable('insertAll');
     RangeError.checkValueInInterval(index, 0, this.length, "index");
     if (iterable is! EfficientLengthIterable) {
@@ skipping 69 matching lines @@
     for (int i = 0; i < retained.length; i++) {
       this[i] = retained[i];
     }
   }
 
   Iterable<E> where(bool f(E element)) {
     return new WhereIterable<E>(this, f);
   }
 
   Iterable/*<T>*/ expand/*<T>*/(Iterable/*<T>*/ f(E element)) {
-    return new ExpandIterable<E, dynamic/*=T*/>(this, f);
+    return new ExpandIterable<E, dynamic/*=T*/ >(this, f);
   }
 
   void addAll(Iterable<E> collection) {
     int i = this.length;
     checkGrowable('addAll');
     for (E e in collection) {
       assert(i == this.length || (throw new ConcurrentModificationError(this)));
       i++;
       JS('void', r'#.push(#)', this, e);
     }
@@ skipping 49 matching lines @@
     for (int i = 1; i < length; i++) {
       // TODO(22407): Improve bounds check elimination to allow this JS code to
       // be replaced by indexing.
       var/*=E*/ element = JS('', '#[#]', this, i);
       value = combine(value, element);
       if (length != this.length) throw new ConcurrentModificationError(this);
     }
     return value;
   }
 
-  /*=T*/ fold/*<T>*/(/*=T*/ initialValue, /*=T*/ combine(/*=T*/ previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(
+      /*=T*/ initialValue, /*=T*/ combine(/*=T*/ previousValue, E element)) {
     var/*=T*/ value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       // TODO(22407): Improve bounds check elimination to allow this JS code to
       // be replaced by indexing.
       var/*=E*/ element = JS('', '#[#]', this, i);
       value = combine(value, element);
       if (this.length != length) throw new ConcurrentModificationError(this);
     }
     return value;
   }
 
   E firstWhere(bool test(E value), {E orElse()}) {
     int end = this.length;
     for (int i = 0; i < end; ++i) {
       // TODO(22407): Improve bounds check elimination to allow this JS code to
       // be replaced by indexing.
       var/*=E*/ element = JS('', '#[#]', this, i);
       if (test(element)) return element;
       if (this.length != end) throw new ConcurrentModificationError(this);
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E lastWhere(bool test(E element), { E orElse() }) {
+  E lastWhere(bool test(E element), {E orElse()}) {
     int length = this.length;
     for (int i = length - 1; i >= 0; i--) {
       // TODO(22407): Improve bounds check elimination to allow this JS code to
       // be replaced by indexing.
       var/*=E*/ element = JS('', '#[#]', this, i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
@@ skipping 23 matching lines @@
     if (matchFound) return match;
     throw IterableElementError.noElement();
   }
 
   E elementAt(int index) {
     return this[index];
   }
 
   List<E> sublist(int start, [int end]) {
     checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
-    if (start is !int) throw argumentErrorValue(start);
+    if (start is! int) throw argumentErrorValue(start);
     if (start < 0 || start > length) {
       throw new RangeError.range(start, 0, length, "start");
     }
     if (end == null) {
       end = length;
     } else {
-      if (end is !int) throw argumentErrorValue(end);
+      if (end is! int) throw argumentErrorValue(end);
       if (end < start || end > length) {
         throw new RangeError.range(end, start, length, "end");
       }
     }
     if (start == end) return <E>[];
-    return new JSArray<E>.typed(
-        JS('', r'#.slice(#, #)', this, start, end));
+    return new JSArray<E>.typed(JS('', r'#.slice(#, #)', this, start, end));
   }
 
-
   Iterable<E> getRange(int start, int end) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<E>(this, start, end);
   }
 
   E get first {
     if (length > 0) return this[0];
     throw IterableElementError.noElement();
   }
 
@@ skipping 77 matching lines @@
       int insertEnd = start + insertLength;
       int newLength = this.length - delta;
       this.setRange(start, insertEnd, replacement);
       if (delta != 0) {
         this.setRange(insertEnd, newLength, this, end);
         this.length = newLength;
       }
     } else {
       int delta = insertLength - removeLength;
       int newLength = this.length + delta;
-      int insertEnd = start + insertLength;  // aka. end + delta.
+      int insertEnd = start + insertLength; // aka. end + delta.
       this.length = newLength;
       this.setRange(insertEnd, newLength, this, end);
       this.setRange(start, insertEnd, replacement);
     }
   }
 
   bool any(bool test(E element)) {
     int end = this.length;
     for (int i = 0; i < end; i++) {
       // TODO(22407): Improve bounds check elimination to allow this JS code to
@@ skipping 81 matching lines @@
     }
     return false;
   }
 
   bool get isEmpty => length == 0;
 
   bool get isNotEmpty => !isEmpty;
 
   String toString() => ListBase.listToString(this);
 
-  List<E> toList({ bool growable: true }) {
+  List<E> toList({bool growable: true}) {
     var list = JS('', '#.slice()', this);
     if (!growable) markFixedList(list);
     return new JSArray<E>.typed(list);
   }
 
   Set<E> toSet() => new Set<E>.from(this);
 
   Iterator<E> get iterator => new ArrayIterator<E>(this);
 
   int get hashCode => Primitives.objectHashCode(this);
 
   int get length => JS('int', r'#.length', this);
 
   void set length(int newLength) {
     checkGrowable('set length');
-    if (newLength is !int) {
+    if (newLength is! int) {
       throw new ArgumentError.value(newLength, 'newLength');
     }
     // TODO(sra): Remove this test and let JavaScript throw an error.
     if (newLength < 0) {
       throw new RangeError.range(newLength, 0, null, 'newLength');
     }
     // JavaScript with throw a RangeError for numbers that are too big. The
     // message does not contain the value.
     JS('void', r'#.length = #', this, newLength);
   }
 
   E operator [](int index) {
-    if (index is !int) throw diagnoseIndexError(this, index);
+    if (index is! int) throw diagnoseIndexError(this, index);
     if (index >= length || index < 0) throw diagnoseIndexError(this, index);
     return JS('var', '#[#]', this, index);
   }
 
   void operator []=(int index, E value) {
     checkMutable('indexed set');
-    if (index is !int) throw diagnoseIndexError(this, index);
+    if (index is! int) throw diagnoseIndexError(this, index);
     if (index >= length || index < 0) throw diagnoseIndexError(this, index);
     JS('void', r'#[#] = #', this, index, value);
   }
 
   Map<int, E> asMap() {
     return new ListMapView<E>(this);
   }
 }
 
 /**
  * Dummy subclasses that allow the backend to track more precise
  * information about arrays through their type. The CPA type inference
  * relies on the fact that these classes do not override [] nor []=.
  *
  * These classes are really a fiction, and can have no methods, since
  * getInterceptor always returns JSArray.  We should consider pushing the
  * 'isGrowable' and 'isMutable' checks into the getInterceptor implementation so
  * these classes can have specialized implementations. Doing so will challenge
  * many assuptions in the JS backend.
  */
 class JSMutableArray<E> extends JSArray<E> {}
+
 class JSFixedArray<E> extends JSMutableArray<E> {}
+
 class JSExtendableArray<E> extends JSMutableArray<E> {}
+
 class JSUnmodifiableArray<E> extends JSArray<E> {} // Already is JSIndexable.
 
-
 /// An [Iterator] that iterates a JSArray.
 ///
 class ArrayIterator<E> implements Iterator<E> {
   final JSArray<E> _iterable;
   final int _length;
   int _index;
   E _current;
 
   ArrayIterator(JSArray<E> iterable)
-      : _iterable = iterable, _length = iterable.length, _index = 0;
+      : _iterable = iterable,
+        _length = iterable.length,
+        _index = 0;
 
   E get current => _current;
 
   bool moveNext() {
     int length = _iterable.length;
 
     // We have to do the length check even on fixed length Arrays.  If we can
     // inline moveNext() we might be able to GVN the length and eliminate this
     // check on known fixed length JSArray.
     if (_length != length) {
       throw throwConcurrentModificationError(_iterable);
     }
 
     if (_index >= length) {
       _current = null;
       return false;
     }
     _current = _iterable[_index];
     _index++;
     return true;
   }
 }