Add breaking changes and release 1.0.0.

lib/src/string_scanner.dart

 // Copyright (c) 2014, 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.
 
 import 'package:charcode/charcode.dart';
 import 'package:source_span/source_span.dart';
 
 import 'exception.dart';
 import 'utils.dart';
 
@@ skipping 14 matching lines @@
   final String string;
 
   /// The current position of the scanner in the string, in characters.
   int get position => _position;
   set position(int position) {
     if (position < 0 || position > string.length) {
       throw new ArgumentError("Invalid position $position");
     }
 
     _position = position;
+    _lastMatch = null;
   }
   int _position = 0;
 
   /// The data about the previous match made by the scanner.
   ///
   /// If the last match failed, this will be `null`.
-  Match get lastMatch => _lastMatch;
+  Match get lastMatch {
+    // Lazily unset [_lastMatch] so that we avoid extra assignments in
+    // character-by-character methods that are used in core loops.
+    if (_position != _lastMatchPosition) _lastMatch = null;
+    return _lastMatch;
+  }
   Match _lastMatch;
+  int _lastMatchPosition;
 
   /// The portion of the string that hasn't yet been scanned.
   String get rest => string.substring(position);
 
   /// Whether the scanner has completely consumed [string].
   bool get isDone => position == string.length;
 
   /// Creates a new [StringScanner] that starts scanning from [position].
   ///
   /// [position] defaults to 0, the beginning of the string. [sourceUrl] is the
@@ skipping 58 matching lines @@
 
     _fail('Expected $name.');
   }
 
   /// If [pattern] matches at the current position of the string, scans forward
   /// until the end of the match.
   ///
   /// Returns whether or not [pattern] matched.
   bool scan(Pattern pattern) {
     var success = matches(pattern);
-    if (success) _position = _lastMatch.end;
+    if (success) {
+      _position = _lastMatch.end;
+      _lastMatchPosition = _position;
+    }
     return success;
   }
 
   /// If [pattern] matches at the current position of the string, scans forward
   /// until the end of the match.
   ///
   /// If [pattern] did not match, throws a [FormatException] describing the
   /// position of the failure. [name] is used in this error as the expected name
   /// of the pattern being matched; if it's `null`, the pattern itself is used
   /// instead.
@@ skipping 20 matching lines @@
     if (isDone) return;
     _fail("no more input");
   }
 
   /// Returns whether or not [pattern] matches at the current position of the
   /// string.
   ///
   /// This doesn't move the scan pointer forward.
   bool matches(Pattern pattern) {
     _lastMatch = pattern.matchAsPrefix(string, position);
+    _lastMatchPosition = _position;
     return _lastMatch != null;
   }
 
   /// Returns the substring of [string] between [start] and [end].
   ///
   /// Unlike [String.substring], [end] defaults to [position] rather than the
   /// end of the string.
   String substring(int start, [int end]) {
     if (end == null) end = position;
     return string.substring(start, end);
   }
 
   /// Throws a [FormatException] with [message] as well as a detailed
   /// description of the location of the error in the string.
   ///
   /// [match] is the match information for the span of the string with which the
   /// error is associated. This should be a match returned by this scanner's
   /// [lastMatch] property. By default, the error is associated with the last
   /// match.
   ///
   /// If [position] and/or [length] are passed, they are used as the error span
   /// instead. If only [length] is passed, [position] defaults to the current
-  /// position; if only [position] is passed, [length] defaults to 1.
+  /// position; if only [position] is passed, [length] defaults to 0.
   ///
   /// It's an error to pass [match] at the same time as [position] or [length].
   void error(String message, {Match match, int position, int length}) {
     validateErrorArgs(string, match, position, length);
 
     if (match == null && position == null && length == null) match = lastMatch;
     if (position == null) {
       position = match == null ? this.position : match.start;
     }
-    if (length == null) length = match == null ? 1 : match.end - match.start;
+    if (length == null) length = match == null ? 0 : match.end - match.start;
 
     var sourceFile = new SourceFile(string, url: sourceUrl);
     var span = sourceFile.span(position, position + length);
     throw new StringScannerException(message, span, string);
   }
 
   // TODO(nweiz): Make this handle long lines more gracefully.
   /// Throws a [FormatException] describing that [name] is expected at the
   /// current position in the string.
   void _fail(String name) {
     error("expected $name.", position: this.position, length: 0);
   }
 }