Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/private/regexp_helper.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._js_helper;
 
 // Helper method used by internal libraries.
 regExpGetNative(JSSyntaxRegExp regexp) => regexp._nativeRegExp;
 
-List<String> _stringList(List l) => l == null ? l : JS('', 'dart.list(#, #)', l, String);
+List<String> _stringList(List l) =>
+    l == null ? l : JS('', 'dart.list(#, #)', l, String);
 
 /**
  * Returns a native version of the RegExp with the global flag set.
  *
  * The RegExp's `lastIndex` property is zero when it is returned.
  *
  * The returned regexp is shared, and its `lastIndex` property may be
  * modified by other uses, so the returned regexp must be used immediately
  * when it's returned, with no user-provided code run in between.
  */
@@ skipping 23 matching lines @@
 
 class JSSyntaxRegExp implements RegExp {
   final String pattern;
   final _nativeRegExp;
   var _nativeGlobalRegExp;
   var _nativeAnchoredRegExp;
 
   String toString() => "RegExp/$pattern/";
 
   JSSyntaxRegExp(String source,
-                 { bool multiLine: false,
-                   bool caseSensitive: true })
+      {bool multiLine: false, bool caseSensitive: true})
       : this.pattern = source,
         this._nativeRegExp =
             makeNative(source, multiLine, caseSensitive, false);
 
   get _nativeGlobalVersion {
     if (_nativeGlobalRegExp != null) return _nativeGlobalRegExp;
-    return _nativeGlobalRegExp = makeNative(pattern,
-                                            _isMultiLine,
-                                            _isCaseSensitive,
-                                            true);
+    return _nativeGlobalRegExp =
+        makeNative(pattern, _isMultiLine, _isCaseSensitive, true);
   }
 
   get _nativeAnchoredVersion {
     if (_nativeAnchoredRegExp != null) return _nativeAnchoredRegExp;
     // An "anchored version" of a regexp is created by adding "|()" to the
     // source. This means that the regexp always matches at the first position
     // that it tries, and you can see if the original regexp matched, or it
     // was the added zero-width match that matched, by looking at the last
     // capture. If it is a String, the match participated, otherwise it didn't.
-    return _nativeAnchoredRegExp = makeNative("$pattern|()",
-                                              _isMultiLine,
-                                              _isCaseSensitive,
-                                              true);
+    return _nativeAnchoredRegExp =
+        makeNative("$pattern|()", _isMultiLine, _isCaseSensitive, true);
   }
 
   bool get _isMultiLine => JS("bool", "#.multiline", _nativeRegExp);
   bool get _isCaseSensitive => JS("bool", "!#.ignoreCase", _nativeRegExp);
 
   static makeNative(
       String source, bool multiLine, bool caseSensitive, bool global) {
     checkString(source);
     String m = multiLine ? 'm' : '';
     String i = caseSensitive ? '' : 'i';
     String g = global ? 'g' : '';
     // We're using the JavaScript's try catch instead of the Dart one
     // to avoid dragging in Dart runtime support just because of using
     // RegExp.
-    var regexp = JS('',
+    var regexp = JS(
+        '',
         '(function() {'
-         'try {'
-          'return new RegExp(#, # + # + #);'
-         '} catch (e) {'
-           'return e;'
-         '}'
-        '})()', source, m, i, g);
+        'try {'
+        'return new RegExp(#, # + # + #);'
+        '} catch (e) {'
+        'return e;'
+        '}'
+        '})()',
+        source,
+        m,
+        i,
+        g);
     if (JS('bool', '# instanceof RegExp', regexp)) return regexp;
     // The returned value is the JavaScript exception. Turn it into a
     // Dart exception.
     String errorMessage = JS('String', r'String(#)', regexp);
-    throw new FormatException(
-        "Illegal RegExp pattern: $source, $errorMessage");
+    throw new FormatException("Illegal RegExp pattern: $source, $errorMessage");
   }
 
   Match firstMatch(String string) {
-    List m = JS('JSExtendableArray|Null',
-                        r'#.exec(#)',
-                        _nativeRegExp,
-                        checkString(string));
+    List m = JS('JSExtendableArray|Null', r'#.exec(#)', _nativeRegExp,
+        checkString(string));
     if (m == null) return null;
     return new _MatchImplementation(this, _stringList(m));
   }
 
   bool hasMatch(String string) {
     return JS('bool', r'#.test(#)', _nativeRegExp, checkString(string));
   }
 
   String stringMatch(String string) {
     var match = firstMatch(string);
@@ skipping 97 matching lines @@
         _current = match;
         int nextIndex = match.end;
         if (match.start == nextIndex) {
           nextIndex++;
         }
         _nextIndex = nextIndex;
         return true;
       }
     }
     _current = null;
-    _string = null;  // Marks iteration as ended.
+    _string = null; // Marks iteration as ended.
     return false;
   }
 }
 
 /** Find the first match of [regExp] in [string] at or after [start]. */
 Match firstMatchAfter(JSSyntaxRegExp regExp, String string, int start) {
   return regExp._execGlobal(string, start);
 }