dartfmt pkg/compiler

pkg/compiler/lib/src/scanner/scanner.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.
 
 library dart2js.scanner;
 
-import '../io/source_file.dart' show
-    SourceFile,
-    Utf8BytesSourceFile;
-import '../tokens/keyword.dart' show
-    Keyword,
-    KeywordState;
+import '../io/source_file.dart' show SourceFile, Utf8BytesSourceFile;
+import '../tokens/keyword.dart' show Keyword, KeywordState;
 import '../tokens/precedence.dart';
 import '../tokens/precedence_constants.dart';
 import '../tokens/token.dart';
 import '../tokens/token_constants.dart';
 import '../util/characters.dart';
 
-import 'string_scanner.dart' show
-    StringScanner;
-import 'utf8_bytes_scanner.dart' show
-    Utf8BytesScanner;
-
+import 'string_scanner.dart' show StringScanner;
+import 'utf8_bytes_scanner.dart' show Utf8BytesScanner;
 
 abstract class Scanner {
   Token tokenize();
 
-  factory Scanner(SourceFile file,
-      {bool includeComments: false}) {
+  factory Scanner(SourceFile file, {bool includeComments: false}) {
     if (file is Utf8BytesSourceFile) {
       return new Utf8BytesScanner(file, includeComments: includeComments);
     } else {
       return new StringScanner(file, includeComments: includeComments);
     }
   }
 }
 
 abstract class AbstractScanner implements Scanner {
   // TODO(ahe): Move this class to implementation.
@@ skipping 25 matching lines @@
 
   /**
    * The source file that is being scanned. This field can be [:null:].
    * If the source file is available, the scanner assigns its [:lineStarts:] and
    * [:length:] fields at the end of [tokenize].
    */
   final SourceFile file;
 
   final List<int> lineStarts = <int>[0];
 
-  AbstractScanner(
-      this.file, this.includeComments) {
+  AbstractScanner(this.file, this.includeComments) {
     this.tail = this.tokens;
   }
 
   /**
    * Advances and returns the next character.
    *
    * If the next character is non-ASCII, then the returned value depends on the
    * scanner implementation. The [Utf8BytesScanner] returns a UTF-8 byte, while
    * the [StringScanner] returns a UTF-16 code unit.
    *
@@ skipping 72 matching lines @@
 
   /**
    * Appends a substring from the scan offset [:start:] to the current
    * [:scanOffset:] plus the [:extraOffset:]. For example, if the current
    * scanOffset is 10, then [:appendSubstringToken(5, -1):] will append the
    * substring string [5,9).
    *
    * Note that [extraOffset] can only be used if the covered character(s) are
    * known to be ASCII.
    */
-  void appendSubstringToken(PrecedenceInfo info, int start,
-                            bool asciiOnly, [int extraOffset]);
+  void appendSubstringToken(PrecedenceInfo info, int start, bool asciiOnly,
+      [int extraOffset]);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   void appendPrecedenceToken(PrecedenceInfo info);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   int select(int choice, PrecedenceInfo yes, PrecedenceInfo no);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   void appendKeywordToken(Keyword keyword);
 
@@ skipping 48 matching lines @@
       // One additional line start at the end, see [SourceFile.lineStarts].
       lineStarts.add(stringOffset + 1);
       file.lineStarts = lineStarts;
     }
 
     return firstToken();
   }
 
   int bigSwitch(int next) {
     beginToken();
-    if (identical(next, $SPACE) || identical(next, $TAB)
-        || identical(next, $LF) || identical(next, $CR)) {
+    if (identical(next, $SPACE) ||
+        identical(next, $TAB) ||
+        identical(next, $LF) ||
+        identical(next, $CR)) {
       appendWhiteSpace(next);
       next = advance();
       // Sequences of spaces are common, so advance through them fast.
       while (identical(next, $SPACE)) {
         // We don't invoke [:appendWhiteSpace(next):] here for efficiency,
         // assuming that it does not do anything for space characters.
         next = advance();
       }
       return next;
     }
@@ skipping 96 matching lines @@
       // Type parameters and arguments cannot contain semicolon.
       discardOpenLt();
       return advance();
     }
 
     if (identical(next, $QUESTION)) {
       return tokenizeQuestion(next);
     }
 
     if (identical(next, $CLOSE_SQUARE_BRACKET)) {
-      return appendEndGroup(CLOSE_SQUARE_BRACKET_INFO,
-                            OPEN_SQUARE_BRACKET_TOKEN);
+      return appendEndGroup(
+          CLOSE_SQUARE_BRACKET_INFO, OPEN_SQUARE_BRACKET_TOKEN);
     }
 
     if (identical(next, $BACKPING)) {
       appendPrecedenceToken(BACKPING_INFO);
       return advance();
     }
 
     if (identical(next, $OPEN_CURLY_BRACKET)) {
       appendBeginGroup(OPEN_CURLY_BRACKET_INFO);
       return advance();
     }
 
     if (identical(next, $CLOSE_CURLY_BRACKET)) {
-      return appendEndGroup(CLOSE_CURLY_BRACKET_INFO,
-                            OPEN_CURLY_BRACKET_TOKEN);
+      return appendEndGroup(CLOSE_CURLY_BRACKET_INFO, OPEN_CURLY_BRACKET_TOKEN);
     }
 
     if (identical(next, $SLASH)) {
       return tokenizeSlashOrComment(next);
     }
 
     if (identical(next, $AT)) {
       return tokenizeAt(next);
     }
 
     if (identical(next, $DQ) || identical(next, $SQ)) {
       return tokenizeString(next, scanOffset, false);
     }
 
     if (identical(next, $PERIOD)) {
       return tokenizeDotsOrNumber(next);
     }
 
     if (identical(next, $0)) {
       return tokenizeHexOrNumber(next);
     }
 
     // TODO(ahe): Would a range check be faster?
-    if (identical(next, $1) || identical(next, $2) || identical(next, $3)
-        || identical(next, $4) ||  identical(next, $5) || identical(next, $6)
-        || identical(next, $7) || identical(next, $8) || identical(next, $9)) {
+    if (identical(next, $1) ||
+        identical(next, $2) ||
+        identical(next, $3) ||
+        identical(next, $4) ||
+        identical(next, $5) ||
+        identical(next, $6) ||
+        identical(next, $7) ||
+        identical(next, $8) ||
+        identical(next, $9)) {
       return tokenizeNumber(next);
     }
 
     if (identical(next, $EOF)) {
       return $EOF;
     }
     if (next < 0x1f) {
       return unexpected(next);
     }
 
@@ skipping 12 matching lines @@
   int tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (scanOffset == 0) {
       if (identical(peek(), $BANG)) {
         int start = scanOffset + 1;
         bool asciiOnly = true;
         do {
           next = advance();
           if (next > 127) asciiOnly = false;
         } while (!identical(next, $LF) &&
-                 !identical(next, $CR) &&
-                 !identical(next, $EOF));
+            !identical(next, $CR) &&
+            !identical(next, $EOF));
         if (!asciiOnly) handleUnicode(start);
         return next;
       }
     }
     appendPrecedenceToken(HASH_INFO);
     return advance();
   }
 
   int tokenizeTilde(int next) {
     // ~ ~/ ~/=
@@ skipping 204 matching lines @@
     }
     return tokenizeNumber(next);
   }
 
   int tokenizeHex(int next) {
     int start = scanOffset;
     next = advance(); // Advance past the $x or $X.
     bool hasDigits = false;
     while (true) {
       next = advance();
-      if (($0 <= next && next <= $9)
-          || ($A <= next && next <= $F)
-          || ($a <= next && next <= $f)) {
+      if (($0 <= next && next <= $9) ||
+          ($A <= next && next <= $F) ||
+          ($a <= next && next <= $f)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           unterminated('0x', shouldAdvance: false);
           return next;
         }
         appendSubstringToken(HEXADECIMAL_INFO, start, true);
         return next;
       }
     }
@@ skipping 88 matching lines @@
           identical($CR, next) ||
           identical($EOF, next)) {
         if (!asciiOnly) handleUnicode(start);
         appendComment(start, asciiOnly);
         return next;
       }
     }
     return null;
   }
 
-
   int tokenizeMultiLineComment(int next, int start) {
     bool asciiOnlyComment = true; // Track if the entire comment is ASCII.
     bool asciiOnlyLines = true; // Track ASCII since the last handleUnicode.
     int unicodeStart = start;
     int nesting = 1;
     next = advance();
     while (true) {
       if (identical($EOF, next)) {
         if (!asciiOnlyLines) handleUnicode(unicodeStart);
         unterminated('/*');
@@ skipping 137 matching lines @@
     while (!identical(next, quoteChar)) {
       if (identical(next, $BACKSLASH)) {
         next = advance();
       } else if (identical(next, $$)) {
         if (!asciiOnly) handleUnicode(start);
         next = tokenizeStringInterpolation(start, asciiOnly);
         start = scanOffset;
         asciiOnly = true;
         continue;
       }
-      if (next <= $CR
-          && (identical(next, $LF) ||
+      if (next <= $CR &&
+          (identical(next, $LF) ||
               identical(next, $CR) ||
               identical(next, $EOF))) {
         if (!asciiOnly) handleUnicode(start);
         return unterminatedString(quoteChar);
       }
       if (next > 127) asciiOnly = false;
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
     // Advance past the quote character.
@@ skipping 14 matching lines @@
   }
 
   int tokenizeInterpolatedExpression(int next) {
     appendBeginGroup(STRING_INTERPOLATION_INFO);
     beginToken(); // The expression starts here.
     next = advance(); // Move past the curly bracket.
     while (!identical(next, $EOF) && !identical(next, $STX)) {
       next = bigSwitch(next);
     }
     if (identical(next, $EOF)) return next;
-    next = advance();  // Move past the $STX.
+    next = advance(); // Move past the $STX.
     beginToken(); // The string interpolation suffix starts here.
     return next;
   }
 
   int tokenizeInterpolatedIdentifier(int next) {
     appendPrecedenceToken(STRING_INTERPOLATION_IDENTIFIER_INFO);
 
     if ($a <= next && next <= $z) {
       beginToken(); // The identifier starts here.
       next = tokenizeKeywordOrIdentifier(next, false);
@@ skipping 206 matching lines @@
 
 PrecedenceInfo closeBraceInfoFor(BeginGroupToken begin) {
   return const {
     '(': CLOSE_PAREN_INFO,
     '[': CLOSE_SQUARE_BRACKET_INFO,
     '{': CLOSE_CURLY_BRACKET_INFO,
     '<': GT_INFO,
     r'${': CLOSE_CURLY_BRACKET_INFO,
   }[begin.value];
 }