Improve performance by not doing binary searches.

lib/src/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.
 
 library yaml.scanner;
 
 import 'package:collection/collection.dart';
 import 'package:string_scanner/string_scanner.dart';
 import 'package:source_span/source_span.dart';
 
@@ skipping 274 matching lines @@
   /// If so, this sets the scanner's last match to that indicator.
   bool get _isDocumentIndicator {
     return _scanner.column == 0 && _isBlankOrEndAt(3) &&
         (_scanner.matches('---') || _scanner.matches('...'));
   }
 
   /// Creates a scanner that scans [source].
   ///
   /// [sourceUrl] can be a String or a [Uri].
   Scanner(String source, {sourceUrl})
-      : _scanner = new SpanScanner(source, sourceUrl: sourceUrl);
+      : _scanner = new SpanScanner.eager(source, sourceUrl: sourceUrl);
 
   /// Consumes and returns the next token.
   Token scan() {
     if (_streamEndProduced) throw new StateError("Out of tokens.");
     if (!_tokenAvailable) _fetchMoreTokens();
 
     var token = _tokens.removeFirst();
     _tokenAvailable = false;
     _tokensParsed++;
     _streamEndProduced = token is Token &&
@@ skipping 172 matching lines @@
 
       // libyaml requires that all simple keys be a single line and no longer
       // than 1024 characters. However, in section 7.4.2 of the spec
       // (http://yaml.org/spec/1.2/spec.html#id2790832), these restrictions are
       // only applied when the curly braces are omitted. It's difficult to
       // retain enough context to know which keys need to have the restriction
       // placed on them, so for now we go the other direction and allow
       // everything but multiline simple keys in a block context.
       if (!_inBlockContext) continue;
 
-      if (key.location.line == _scanner.line) continue;
+      if (key.line == _scanner.line) continue;
 
       if (key.required) {
         throw new YamlException("Expected ':'.", _scanner.emptySpan);
       }
 
       _simpleKeys[i] = null;
     }
   }
 
   /// Checks if a simple key may start at the current position and saves it if
   /// so.
   void _saveSimpleKey() {
     // A simple key is required at the current position if the scanner is in the
     // block context and the current column coincides with the indentation
     // level.
     var required = _inBlockContext && _indent == _scanner.column;
 
     // A simple key is required only when it is the first token in the current
     // line. Therefore it is always allowed. But we add a check anyway.
     assert(_simpleKeyAllowed || !required);
 
     if (!_simpleKeyAllowed) return;
 
     // If the current position may start a simple key, save it.
     _removeSimpleKey();
     _simpleKeys[_simpleKeys.length - 1] = new _SimpleKey(
         _tokensParsed + _tokens.length,
+        _scanner.line,
+        _scanner.column,
         _scanner.location,
         required: required);
   }
 
   /// Removes a potential simple key at the current flow level.
   void _removeSimpleKey() {
     var key = _simpleKeys.last;
     if (key != null && key.required) {
       throw new YamlException("Could not find expected ':' for simple key.",
           key.location.pointSpan());
@@ skipping 127 matching lines @@
     if (_inBlockContext) {
       if (!_simpleKeyAllowed) {
         throw new YamlException(
             "Block sequence entries are not allowed here.",
             _scanner.emptySpan);
       }
 
       _rollIndent(
           _scanner.column,
           TokenType.BLOCK_SEQUENCE_START,
-          _scanner.emptySpan.start);
+          _scanner.location);
     } else {
       // It is an error for the '-' indicator to occur in the flow context, but
       // we let the Parser detect and report it because it's able to point to
       // the context.
     }
 
     _removeSimpleKey();
     _simpleKeyAllowed = true;
     _addCharToken(TokenType.BLOCK_ENTRY);
   }
 
   /// Produces the [TokenType.KEY] token.
   void _fetchKey() {
     if (_inBlockContext) {
       if (!_simpleKeyAllowed) {
         throw new YamlException("Mapping keys are not allowed here.",
             _scanner.emptySpan);
       }
 
       _rollIndent(
           _scanner.column,
           TokenType.BLOCK_MAPPING_START,
-          _scanner.emptySpan.start);
+          _scanner.location);
     }
 
     // Simple keys are allowed after `?` in a block context.
     _simpleKeyAllowed = _inBlockContext;
     _addCharToken(TokenType.KEY);
   }
 
   /// Produces the [TokenType.VALUE] token.
   void _fetchValue() {
     var simpleKey = _simpleKeys.last;
     if (simpleKey != null) {
       // Add a [TokenType.KEY] directive before the first token of the simple
       // key so the parser knows that it's part of a key/value pair.
       _tokens.insert(simpleKey.tokenNumber - _tokensParsed,
           new Token(TokenType.KEY, simpleKey.location.pointSpan()));
 
       // In the block context, we may need to add the
       // [TokenType.BLOCK_MAPPING_START] token.
       _rollIndent(
-          simpleKey.location.column,
+          simpleKey.column,
           TokenType.BLOCK_MAPPING_START,
           simpleKey.location,
           tokenNumber: simpleKey.tokenNumber);
 
       // Remove the simple key.
       _simpleKeys[_simpleKeys.length - 1] = null;
 
       // A simple key cannot follow another simple key.
       _simpleKeyAllowed = false;
     } else if (_inBlockContext) {
@@ skipping 915 matching lines @@
   /// This is the index relative to all tokens emitted, rather than relative to
   /// [_tokens].
   final int tokenNumber;
 
   /// The source location of the beginning of the simple key.
   ///
   /// This is used for error reporting and for determining when a simple key is
   /// no longer on the current line.
   final SourceLocation location;
 
+  /// The line on which the key appears.
+  ///
+  /// We could get this from [location], but that requires a binary search
+  /// whereas this is O(1).
+  final int line;
+
+  /// The column on which the key appears.
+  ///
+  /// We could get this from [location], but that requires a binary search
+  /// whereas this is O(1).
+  final int column;
+
   /// Whether this key must exist for the document to be scanned.
   final bool required;
 
-  _SimpleKey(this.tokenNumber, this.location, {bool required})
+  _SimpleKey(this.tokenNumber, this.line, this.column, this.location,
+          {bool required})
       : required = required;
 }
 
 /// An enum of chomping indicators that describe how to handle trailing
 /// whitespace for a block scalar.
 ///
 /// See http://yaml.org/spec/1.2/spec.html#id2794534.
 class _Chomping {
   /// All trailing whitespace is discarded.
   static const STRIP = const _Chomping("STRIP");
 
   /// A single trailing newline is retained.
   static const CLIP = const _Chomping("CLIP");
 
   /// All trailing whitespace is preserved.
   static const KEEP = const _Chomping("KEEP");
 
   final String name;
 
   const _Chomping(this.name);
 
   String toString() => name;
 }