Incorporates feedback by Nicolas for UTF-8 bytes based scanner CL

sdk/lib/_internal/compiler/implementation/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.
 
 part of scanner;
 
 abstract class Scanner {
   Token tokenize();
 
   factory Scanner(SourceFile file, {bool includeComments: false}) {
@@ skipping 31 matching lines @@
    */
   Token tail;
 
   /**
    * 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 = [0];
+  final List<int> lineStarts = <int>[0];
 
   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.
    *
    * The scanner ensures that [advance] is not invoked after it returned [$EOF].
    * This allows implementations to omit bound checks if the data structure ends
    * with '0'.
    */
   int advance();
 
   /**
    * Returns the current unicode character.
    *
    * If the current character is ASCII, then it is returned unchanged.
    *
    * The [Utf8BytesScanner] decodes the next unicode code point starting at the
    * current position. Note that every unicode character is returned as a single
-   * code point, i.e., for '\u{1d11e}' it returns 119070, and the following
+   * code point, that is, for '\u{1d11e}' it returns 119070, and the following
    * [advance] returns the next character.
    *
    * The [StringScanner] returns the current character unchanged, which might
    * be a surrogate character. In the case of '\u{1d11e}', it returns the first
    * code unit 55348, and the following [advance] returns the second code unit
    * 56606.
    *
    * Invoking [currentAsUnicode] multiple times is safe, i.e.,
    * [:currentAsUnicode(next) == currentAsUnicode(currentAsUnicode(next)):].
    */
@@ skipping 758 matching lines @@
       }
     }
     if (raw) {
       return tokenizeSingleLineRawString(next, quoteChar, start);
     } else {
       return tokenizeSingleLineString(next, quoteChar, start);
     }
   }
 
   /**
-   * [next] is the first character after the qoute.
+   * [next] is the first character after the quote.
    * [start] is the scanOffset of the quote.
    *
    * The token contains a substring of the source file, including the
    * string quotes, backslashes for escaping. For interpolated strings,
    * the parts before and after are separate tokens.
    *
    *   "a $b c"
    *
    * gives StringToken("a $), StringToken(b) and StringToken( c").
    */
@@ skipping 53 matching lines @@
   int tokenizeInterpolatedIdentifier(int next) {
     appendPrecedenceToken(STRING_INTERPOLATION_IDENTIFIER_INFO);
     beginToken(); // The identifier starts here.
     next = tokenizeKeywordOrIdentifier(next, false);
     beginToken(); // The string interpolation suffix starts here.
     return next;
   }
 
   int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     bool asciiOnly = true;
-    next = advance(); // Advance past the quote
+    next = advance(); // Advance past the quote.
     while (next != $EOF) {
       if (identical(next, quoteChar)) {
         if (!asciiOnly) handleUnicode(start);
         next = advance();
         appendSubstringToken(STRING_INFO, start, asciiOnly);
         return next;
       } else if (identical(next, $LF) || identical(next, $CR)) {
         if (!asciiOnly) handleUnicode(start);
         return error("unterminated string literal");
       } else if (next > 127) {
         asciiOnly = false;
       }
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
     return error("unterminated string literal");
   }
 
   int tokenizeMultiLineRawString(int quoteChar, int start) {
     bool asciiOnlyString = true;
     bool asciiOnlyLine = true;
     int unicodeStart = start;
-    int next = advance(); // Advance past the (last) quote (of three)
+    int next = advance(); // Advance past the (last) quote (of three).
     outer: while (!identical(next, $EOF)) {
       while (!identical(next, quoteChar)) {
         if (identical(next, $LF)) {
           if (!asciiOnlyLine) {
             // Synchronize the string offset in the utf8 scanner.
             handleUnicode(unicodeStart);
             asciiOnlyLine = true;
             unicodeStart = scanOffset;
           }
           lineFeedInMultiline();
@@ skipping 72 matching lines @@
 
   int error(String message) {
     appendStringToken(BAD_INPUT_INFO, message);
     return advance(); // Ensure progress.
   }
 
   void unmatchedBeginGroup(BeginGroupToken begin) {
     String error = 'unmatched "${begin.stringValue}"';
     Token close =
         new StringToken.fromString(
-            BAD_INPUT_INFO, error, begin.charOffset, true);
+            BAD_INPUT_INFO, error, begin.charOffset, canonicalize: true);
 
     // We want to ensure that unmatched BeginGroupTokens are reported
-    // as errors. However, the rest of the parser assume the groups
+    // as errors. However, the rest of the parser assumes the groups
     // are well-balanced and will never look at the endGroup
     // token. This is a nice property that allows us to skip quickly
     // over correct code. By inserting an additional error token in
     // the stream, we can keep ignoring endGroup tokens.
     //
     // [begin] --next--> [tail]
     // [begin] --endG--> [close] --next--> [next] --next--> [tail]
     //
     // This allows the parser to skip from [begin] via endGroup to [close] and
     // ignore the [close] token (assuming it's correct), then the error will be
     // reported when parsing the [next] token.
 
     Token next = new StringToken.fromString(
-        BAD_INPUT_INFO, error, begin.charOffset, true);
+        BAD_INPUT_INFO, error, begin.charOffset, canonicalize: true);
     begin.endGroup = close;
     close.next = next;
     next.next = begin.next;
   }
 }