Fix crashes in scanner.

dart/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}) {
     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.
+
   final bool includeComments;
 
   /**
    * The string offset for the next token that will be created.
    *
    * Note that in the [Utf8BytesScanner], [stringOffset] and [scanOffset] values
    * are different. One string character can be encoded using multiple UTF-8
    * bytes.
    */
   int tokenStart = -1;
@@ skipping 149 matching lines @@
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   void appendGtGt(PrecedenceInfo info);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   void appendComment(start, bool asciiOnly);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
   void discardOpenLt();
 
-  // TODO(ahe): Move this class to implementation.
+  /// Return true when at EOF.
+  bool atEndOfFile();
 
   Token tokenize() {
-    int next = advance();
-    while (!identical(next, $EOF)) {
-      next = bigSwitch(next);
+    while (!atEndOfFile()) {
+      int next = advance();
+      while (!identical(next, $EOF)) {
+        next = bigSwitch(next);
+      }
+      if (atEndOfFile()) {
+        appendEofToken();
+      } else {
+        error('blah');

[Johnni Winther, 2013/11/26 12:11:12]

Strange error message!

[ahe, 2013/11/29 10:48:38]

Done.

+      }
     }
-    appendEofToken();
 
     if (file != null) {
       file.length = stringOffset;
       // One additional line start at the end, see [SourceFile.lineStarts].
       lineStarts.add(stringOffset + 1);
       file.lineStarts = lineStarts;
     }
 
     return firstToken();
   }
@@ skipping 707 matching lines @@
     }
     if (identical(next, $EOF)) return next;
     next = advance();  // Move past the $STX.
     beginToken(); // The string interpolation suffix starts here.
     return next;
   }
 
   int tokenizeInterpolatedIdentifier(int next) {
     appendPrecedenceToken(STRING_INTERPOLATION_IDENTIFIER_INFO);
     beginToken(); // The identifier starts here.
-    next = tokenizeKeywordOrIdentifier(next, false);
+
+    if ($a <= next && next <= $z) {
+      next = tokenizeKeywordOrIdentifier(next, false);
+    } else if (($A <= next && next <= $Z) || identical(next, $_)) {
+      next = tokenizeIdentifier(next, scanOffset, false);
+    } else {
+      error("expected identifier or '{'", shouldAdvance: 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.
     while (next != $EOF) {
       if (identical(next, quoteChar)) {
         if (!asciiOnly) handleUnicode(start);
@@ skipping 93 matching lines @@
       } else if (next > 127) {
         asciiOnlyString = false;
         asciiOnlyLine = false;
       }
       next = advance();
     }
     if (!asciiOnlyLine) handleUnicode(unicodeStart);
     return error("unterminated string literal");
   }
 
-  int error(String message) {
+  int error(String message, {bool shouldAdvance: true}) {
     appendStringToken(BAD_INPUT_INFO, message);
-    return advance(); // Ensure progress.
+    if (atEndOfFile()) return $EOF;
+    if (shouldAdvance) {
+      return advance(); // Ensure progress.
+    } else {
+      return -1;
+    }
   }
 
   void unmatchedBeginGroup(BeginGroupToken begin) {
     String error = 'unmatched "${begin.stringValue}"';
     Token close =
         new StringToken.fromString(
             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 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, canonicalize: true);
     begin.endGroup = close;
     close.next = next;
     next.next = begin.next;
   }
 }