Run dartfmt on pkg/front_end/lib.

pkg/front_end/lib/src/fasta/scanner/recover.dart

 // Copyright (c) 2017, 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 licenset hat can be found in the LICENSE file.
 
 library fasta.scanner.recover;
 
-import 'token.dart' show
-    StringToken,
-    Token;
+import 'token.dart' show StringToken, Token;
 
-import 'error_token.dart' show
-    NonAsciiIdentifierToken,
-    ErrorKind,
-    ErrorToken;
+import 'error_token.dart' show NonAsciiIdentifierToken, ErrorKind, ErrorToken;
 
 import 'precedence.dart' as Precedence;
 
-import 'precedence.dart' show
-    PrecedenceInfo;
+import 'precedence.dart' show PrecedenceInfo;
 
 /// Recover from errors in [tokens]. The original sources are provided as
 /// [bytes]. [lineStarts] are the beginning character offsets of lines, and
 /// must be updated if recovery is performed rewriting the original source
 /// code.
 Token defaultRecoveryStrategy(
     List<int> bytes, Token tokens, List<int> lineStarts) {
   // See [Parser.reportErrorToken](package:front_end/src/fasta/parser/src/parser.dart) for how
   // it currently handles lexical errors. In addition, notice how the parser
   // calls [handleInvalidExpression], [handleInvalidFunctionBody], and
   // [handleInvalidTypeReference] to allow the listener to recover its internal
   // state. See [package:compiler/src/parser/element_listener.dart] for an
   // example of how these events are used.
   //
   // In addition, the scanner will attempt a bit of recovery when braces don't
   // match up during brace grouping. See
   // [ArrayBasedScanner.discardBeginGroupUntil](array_based_scanner.dart). For
   // more details on brace grouping see
   // [AbstractScanner.unmatchedBeginGroup](abstract_scanner.dart).
 
   /// Tokens with errors.
   ErrorToken error;
+
   /// Used for appending to [error].
   ErrorToken errorTail;
 
   /// Tokens without errors.
   Token good;
+
   /// Used for appending to [good].
   Token goodTail;
 
   /// The previous token appended to [good]. Since tokens are single linked
   /// lists, this allows us to rewrite the current token without scanning all
   /// of [good]. This is supposed to be the token immediately before
   /// [goodTail], that is, `beforeGoodTail.next == goodTail`.
   Token beforeGoodTail;
 
   recoverIdentifier(NonAsciiIdentifierToken first) {
@@ skipping 50 matching lines @@
       } else {
         goodTail = beforeGoodTail;
       }
     }
     if (append) {
       codeUnits.addAll(next.value.codeUnits);
       next = next.next;
     }
     String value = new String.fromCharCodes(codeUnits);
     return synthesizeToken(charOffset, value, Precedence.IDENTIFIER_INFO)
-        ..next = next;
+      ..next = next;
   }
 
   recoverExponent() {
     return synthesizeToken(errorTail.charOffset, "NaN", Precedence.DOUBLE_INFO)
-        ..next = errorTail.next;
+      ..next = errorTail.next;
   }
 
   recoverString() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
   }
 
   recoverHexDigit() {
     return synthesizeToken(errorTail.charOffset, "-1", Precedence.INT_INFO)
-        ..next = errorTail.next;
+      ..next = errorTail.next;
   }
 
   recoverStringInterpolation() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
   }
 
   recoverComment() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
@@ skipping 96 matching lines @@
 
 String closeBraceFor(String openBrace) {
   return const {
     '(': ')',
     '[': ']',
     '{': '}',
     '<': '>',
     r'${': '}',
   }[openBrace];
 }