Generate tear-off closures dynamically.

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}) {
@@ skipping 358 matching lines @@
     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 error("unexpected character $next");
+      return error("unexpected character $next", next);
     }
 
     next = currentAsUnicode(next);
 
     // The following are non-ASCII characters.
 
     if (identical(next, $NBSP)) {
       appendWhiteSpace(next);
       return advance();
     }
 
-    return error("unexpected unicode character $next");
+    return error("unexpected unicode character $next", next);
   }
 
   int tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (scanOffset == 0) {
       if (identical(peek(), $BANG)) {
         int start = scanOffset + 1;
         bool asciiOnly = true;
         do {
           next = advance();
@@ skipping 209 matching lines @@
     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)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
-          return error("hex digit expected");
+          return error("hex digit expected", next);
         }
         appendSubstringToken(HEXADECIMAL_INFO, start, true);
         return next;
       }
     }
   }
 
   int tokenizeDotsOrNumber(int next) {
     int start = scanOffset;
     next = advance();
@@ skipping 43 matching lines @@
   int tokenizeExponent(int next) {
     if (identical(next, $PLUS) || identical(next, $MINUS)) {
       next = advance();
     }
     bool hasDigits = false;
     while (true) {
       if ($0 <= next && next <= $9) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
-          return error("digit expected");
+          return error("digit expected", next);
         }
         return next;
       }
       next = advance();
     }
   }
 
   int tokenizeSlashOrComment(int next) {
     int start = scanOffset;
     next = advance();
@@ skipping 115 matching lines @@
     while (true) {
       if (($a <= next && next <= $z) ||
           ($A <= next && next <= $Z) ||
           ($0 <= next && next <= $9) ||
           identical(next, $_) ||
           (identical(next, $$) && allowDollar)) {
         next = advance();
       } else {
         // Identifier ends here.
         if (start == scanOffset) {
-          return error("expected identifier");
+          return error("expected identifier", next);
         } else {
           appendSubstringToken(IDENTIFIER_INFO, start, true);
         }
         return next;
       }
     }
   }
 
   int tokenizeAt(int next) {
     appendPrecedenceToken(AT_INFO);
@@ skipping 43 matching lines @@
         next = tokenizeStringInterpolation(start, asciiOnly);
         start = scanOffset;
         asciiOnly = true;
         continue;
       }
       if (next <= $CR
           && (identical(next, $LF) ||
               identical(next, $CR) ||
               identical(next, $EOF))) {
         if (!asciiOnly) handleUnicode(start);
-        return error("unterminated string literal");
+        return error("unterminated string literal", next);
       }
       if (next > 127) asciiOnly = false;
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
     // Advance past the quote character.
     next = advance();
     appendSubstringToken(STRING_INFO, start, asciiOnly);
     return next;
   }
@@ skipping 34 matching lines @@
     bool asciiOnly = true;
     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");
+        return error("unterminated string literal", next);
       } else if (next > 127) {
         asciiOnly = false;
       }
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
-    return error("unterminated string literal");
+    return error("unterminated string literal", next);
   }
 
   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).
     outer: while (!identical(next, $EOF)) {
       while (!identical(next, quoteChar)) {
         if (identical(next, $LF)) {
@@ skipping 16 matching lines @@
         next = advance();
         if (identical(next, quoteChar)) {
           if (!asciiOnlyLine) handleUnicode(unicodeStart);
           next = advance();
           appendSubstringToken(STRING_INFO, start, asciiOnlyString);
           return next;
         }
       }
     }
     if (!asciiOnlyLine) handleUnicode(unicodeStart);
-    return error("unterminated string literal");
+    return error("unterminated string literal", next);
   }
 
   int tokenizeMultiLineString(int quoteChar, int start, bool raw) {
     if (raw) return tokenizeMultiLineRawString(quoteChar, start);
     bool asciiOnlyString = true;
     bool asciiOnlyLine = true;
     int unicodeStart = start;
     int next = advance(); // Advance past the (last) quote (of three).
     while (!identical(next, $EOF)) {
       if (identical(next, $$)) {
@@ skipping 30 matching lines @@
           unicodeStart = scanOffset;
         }
         lineFeedInMultiline();
       } else if (next > 127) {
         asciiOnlyString = false;
         asciiOnlyLine = false;
       }
       next = advance();
     }
     if (!asciiOnlyLine) handleUnicode(unicodeStart);
-    return error("unterminated string literal");
+    return error("unterminated string literal", next);
   }
 
-  int error(String message) {
+  int error(String message, next) {
     appendStringToken(BAD_INPUT_INFO, message);
+    if (next == 0) return 0;
     return advance(); // Ensure progress.
   }
 
   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
@@ skipping 10 matching lines @@
     // 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;
   }
 }