Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/lib/js/dart2js/js_dart2js.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.
 
 /**
  * Support for interoperating with JavaScript.
  *
  * This library provides access to JavaScript objects from Dart, allowing
  * Dart code to get and set properties, and call methods of JavaScript objects
  * and invoke JavaScript functions. The library takes care of converting
@@ skipping 266 matching lines @@
       throw new NoSuchMethodError(_jsObject, new Symbol(method), args, {});
     }
     return _convertToDart(JS('', '#.apply(#, #)', fn, _jsObject, args));
   }
 }
 
 /**
  * Proxies a JavaScript Function object.
  */
 class JsFunction extends JsObject {
-
   /**
    * Returns a [JsFunction] that captures its 'this' binding and calls [f]
    * with the value of this passed as the first argument.
    */
   factory JsFunction.withThis(Function f) {
-    return new JsFunction._fromJs(JS('', 'function(/*...arguments*/) {'
+    return new JsFunction._fromJs(JS(
+        '',
+        'function(/*...arguments*/) {'
         '  let args = [#(this)];'
         '  for (let arg of arguments) {'
         '    args.push(#(arg));'
         '  }'
         '  return #(#(...args));'
-        '}', _convertToDart, _convertToDart, _convertToJS, f));
+        '}',
+        _convertToDart,
+        _convertToDart,
+        _convertToJS,
+        f));
   }
 
   JsFunction._fromJs(jsObject) : super._fromJs(jsObject);
 
   /**
    * Invokes the JavaScript function with arguments [args]. If [thisArg] is
    * supplied it is the value of `this` for the invocation.
    */
-  dynamic apply(List args, {thisArg}) => _convertToDart(JS('', '#.apply(#, #)',
-      _jsObject, _convertToJS(thisArg),
+  dynamic apply(List args, {thisArg}) => _convertToDart(JS(
+      '',
+      '#.apply(#, #)',
+      _jsObject,
+      _convertToJS(thisArg),
       args == null ? null : new List.from(args.map(_convertToJS))));
 }
 
 // TODO(jmesserly): this is totally unnecessary in dev_compiler.
 /** A [List] that proxies a JavaScript array. */
 class JsArray<E> extends JsObject with ListMixin<E> {
-
   /**
    * Creates a new JavaScript array.
    */
   JsArray() : super._fromJs([]);
 
   /**
    * Creates a new JavaScript array and initializes it to the contents of
    * [other].
    */
   JsArray.from(Iterable<E> other)
@@ skipping 87 matching lines @@
   void removeRange(int start, int end) {
     _checkRange(start, end, length);
     callMethod('splice', [start, end - start]);
   }
 
   void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
     _checkRange(start, end, this.length);
     int length = end - start;
     if (length == 0) return;
     if (skipCount < 0) throw new ArgumentError(skipCount);
-    var args = <Object>[start, length]..addAll(iterable.skip(skipCount).take(length));
+    var args = <Object>[start, length]
+      ..addAll(iterable.skip(skipCount).take(length));
     callMethod('splice', args);
   }
 
   void sort([int compare(E a, E b)]) {
     // Note: arr.sort(null) is a type error in FF
     callMethod('sort', compare == null ? [] : [compare]);
   }
 }
 
 // Cross frame objects should not be considered browser types.
 // We include the the instanceof Object test to filter out cross frame objects
 // on FireFox. Surprisingly on FireFox the instanceof Window test succeeds for
 // cross frame windows while the instanceof Object test fails.
-bool _isBrowserType(o) => JS('bool',
+bool _isBrowserType(o) => JS(
+    'bool',
     '# instanceof Object && ('
     '# instanceof Blob || '
     '# instanceof Event || '
     '(window.KeyRange && # instanceof KeyRange) || '
     '(window.IDBKeyRange && # instanceof IDBKeyRange) || '
     '# instanceof ImageData || '
     '# instanceof Node || '
     // Int8Array.__proto__ is TypedArray.
     '(window.Int8Array && # instanceof Int8Array.__proto__) || '
-    '# instanceof Window)', o, o, o, o, o, o, o, o, o);
+    '# instanceof Window)',
+    o,
+    o,
+    o,
+    o,
+    o,
+    o,
+    o,
+    o,
+    o);
 
 class _DartObject {
   final _dartObj;
   _DartObject(this._dartObj);
 }
 
 dynamic _convertToJS(dynamic o) {
-  if (o == null ||
-      o is String ||
-      o is num ||
-      o is bool ||
-      _isBrowserType(o)) {
+  if (o == null || o is String || o is num || o is bool || _isBrowserType(o)) {
     return o;
   } else if (o is DateTime) {
     return Primitives.lazyAsJsDate(o);
   } else if (o is JsObject) {
     return o._jsObject;
   } else if (o is Function) {
     return _putIfAbsent(_jsProxies, o, _wrapDartFunction);
   } else {
     // TODO(jmesserly): for now, we wrap other objects, to keep compatibility
     // with the original dart:js behavior.
     return _putIfAbsent(_jsProxies, o, (o) => new _DartObject(o));
   }
 }
 
 dynamic _wrapDartFunction(f) {
-  var wrapper = JS('', 'function(/*...arguments*/) {'
+  var wrapper = JS(
+      '',
+      'function(/*...arguments*/) {'
       '  let args = Array.prototype.map.call(arguments, #);'
       '  return #(#(...args));'
-      '}', _convertToDart, _convertToJS, f);
+      '}',
+      _convertToDart,
+      _convertToJS,
+      f);
   JS('', '#.set(#, #)', _dartProxies, wrapper, f);
 
   return wrapper;
 }
 
 // converts a Dart object to a reference to a native JS object
 // which might be a DartObject JS->Dart proxy
 Object _convertToDart(o) {
   if (JS('bool', '# == null', o) ||
       JS('bool', 'typeof # == "string"', o) ||
       JS('bool', 'typeof # == "number"', o) ||
       JS('bool', 'typeof # == "boolean"', o) ||
       _isBrowserType(o)) {
     return o;
   } else if (JS('bool', '# instanceof Date', o)) {
     var ms = JS('num', '#.getTime()', o);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   } else if (o is _DartObject &&
-             JS('bool', 'dart.jsobject != dart.getReifiedType(#)', o)) {
+      JS('bool', 'dart.jsobject != dart.getReifiedType(#)', o)) {
     return o._dartObj;
   } else {
     return _wrapToDart(o);
   }
 }
 
 Object _wrapToDart(o) => _putIfAbsent(_dartProxies, o, _wrapToDartHelper);
 
 Object _wrapToDartHelper(o) {
   if (JS('bool', 'typeof # == "function"', o)) {
@@ skipping 25 matching lines @@
 /// using the package:js Dart-JavaScript interop.
 ///
 /// For performance reasons in Dart2Js, by default Dart functions cannot be
 /// passed directly to JavaScript unless this method is called to create
 /// a Function compatible with both Dart and JavaScript.
 /// Calling this method repeatedly on a function will return the same function.
 /// The [Function] returned by this method can be used from both Dart and
 /// JavaScript. We may remove the need to call this method completely in the
 /// future if Dart2Js is refactored so that its function calling conventions
 /// are more compatible with JavaScript.
-Function /*=F*/ allowInterop/*<F extends Function>*/(Function /*=F*/ f) => f;
+Function/*=F*/ allowInterop/*<F extends Function>*/(Function/*=F*/ f) => f;
 
 Expando<Function> _interopCaptureThisExpando = new Expando<Function>();
 
 /// Returns a [Function] that when called from JavaScript captures its 'this'
 /// binding and calls [f] with the value of this passed as the first argument.
 /// When called from Dart, [null] will be passed as the first argument.
 ///
 /// See the documention for [allowInterop]. This method should only be used with
 /// package:js Dart-JavaScript interop.
 Function allowInteropCaptureThis(Function f) {
   var ret = _interopCaptureThisExpando[f];
   if (ret == null) {
-    ret = JS('',
+    ret = JS(
+        '',
         'function(/*...arguments*/) {'
         '  let args = [this];'
         '  for (let arg of arguments) {'
         '    args.push(arg);'
         '  }'
         '  return #(...args);'
         '}',
         f);
     _interopCaptureThisExpando[f] = ret;
   }
   return ret;
 }