Roll Observatory packages and add a roll script

packages/yaml/lib/src/parser.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.parser;
 
 import 'package:source_span/source_span.dart';
 import 'package:string_scanner/string_scanner.dart';
 
 import 'event.dart';
@@ skipping 97 matching lines @@
         return _parseFlowMappingValue(empty: true);
       default:
         throw "Unreachable";
     }
   }
 
   /// Parses the production:
   ///
   ///     stream ::=
   ///       STREAM-START implicit_document? explicit_document* STREAM-END
-  ///       ************  
+  ///       ************
   Event _parseStreamStart() {
     var token = _scanner.scan();
     assert(token.type == TokenType.STREAM_START);
 
     _state = _State.DOCUMENT_START;
     return new Event(EventType.STREAM_START, token.span);
   }
 
   /// Parses the productions:
   ///
@@ skipping 47 matching lines @@
     return new DocumentStartEvent(start.expand(token.span),
         versionDirective: versionDirective,
         tagDirectives: tagDirectives,
         isImplicit: false);
   }
 
   /// Parses the productions:
   ///
   ///     explicit_document    ::=
   ///       DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-  ///                                 ***********  
+  ///                                 ***********
   Event _parseDocumentContent() {
     var token = _scanner.peek();
 
     switch (token.type) {
       case TokenType.VERSION_DIRECTIVE:
       case TokenType.TAG_DIRECTIVE:
       case TokenType.DOCUMENT_START:
       case TokenType.DOCUMENT_END:
       case TokenType.STREAM_END:
         _state = _states.removeLast();
@@ skipping 56 matching lines @@
 
     if (token is AliasToken) {
       _scanner.scan();
       _state = _states.removeLast();
       return new AliasEvent(token.span, token.name);
     }
 
     var anchor;
     var tagToken;
     var span = token.span.start.pointSpan();
-    parseAnchor() {
+    parseAnchor(token) {
       anchor = token.name;
       span = span.expand(token.span);
-      token = _scanner.advance();
+      return _scanner.advance();
     }
 
-    parseTag() {
+    parseTag(token) {
       tagToken = token;
       span = span.expand(token.span);
-      token = _scanner.advance();
+      return _scanner.advance();
     }
 
     if (token is AnchorToken) {
-      parseAnchor();
-      if (token is TagToken) parseTag();
+      token = parseAnchor(token);
+      if (token is TagToken) token = parseTag(token);
     } else if (token is TagToken) {
-      parseTag();
-      if (token is AnchorToken) parseAnchor();
+      token = parseTag(token);
+      if (token is AnchorToken) token = parseAnchor(token);
     }
 
     var tag;
     if (tagToken != null) {
       if (tagToken.handle == null) {
         tag = tagToken.suffix;
       } else {
         var tagDirective = _tagDirectives[tagToken.handle];
         if (tagDirective == null) {
           throw new YamlException("Undefined tag handle.", tagToken.span);
@@ skipping 164 matching lines @@
   }
 
   /// Parses the productions:
   ///
   ///     block_mapping        ::= BLOCK-MAPPING_START
   ///
   ///                              ((KEY block_node_or_indentless_sequence?)?
   ///
   ///                              (VALUE block_node_or_indentless_sequence?)?)*
   ///                               ***** *
-  ///                              BLOCK-END  
+  ///                              BLOCK-END
   ///
   Event _parseBlockMappingValue() {
     var token = _scanner.peek();
 
     if (token.type != TokenType.VALUE) {
       _state = _State.BLOCK_MAPPING_KEY;
       return _processEmptyScalar(token.span.start);
     }
 
     var start = token.span.start;
@@ skipping 44 matching lines @@
             token.span, CollectionStyle.FLOW);
       } else if (token.type != TokenType.FLOW_SEQUENCE_END) {
         _states.add(_State.FLOW_SEQUENCE_ENTRY);
         return _parseNode();
       }
     }
 
     _scanner.scan();
     _state = _states.removeLast();
     return new Event(EventType.SEQUENCE_END, token.span);
-  }  
+  }
 
   /// Parses the productions:
   ///
   ///     flow_sequence_entry  ::=
   ///       flow_node | KEY flow_node? (VALUE flow_node?)?
   ///                   *** *
   Event _parseFlowSequenceEntryMappingKey() {
     var token = _scanner.peek();
 
     if (token.type == TokenType.VALUE ||
@@ skipping 122 matching lines @@
 
   /// Generate an empty scalar event.
   Event _processEmptyScalar(SourceLocation location) =>
       new ScalarEvent(location.pointSpan(), '', ScalarStyle.PLAIN);
 
   /// Parses directives.
   Pair<VersionDirective, List<TagDirective>> _processDirectives() {
     var token = _scanner.peek();
 
     var versionDirective;
-    var tagDirectives = [];
+    var tagDirectives = <TagDirective>[];
     while (token.type == TokenType.VERSION_DIRECTIVE ||
            token.type == TokenType.TAG_DIRECTIVE) {
       if (token is VersionDirectiveToken) {
         if (versionDirective != null) {
           throw new YamlException("Duplicate %YAML directive.", token.span);
         }
 
         if (token.major != 1 || token.minor == 0) {
           throw new YamlException(
               "Incompatible YAML document. This parser only supports YAML 1.1 "
                 "and 1.2.",
               token.span);
         } else if (token.minor > 2) {
           // TODO(nweiz): Print to stderr when issue 6943 is fixed and dart:io
           // is available.
           warn("Warning: this parser only supports YAML 1.1 and 1.2.",
               token.span);
         }
 
         versionDirective = new VersionDirective(token.major, token.minor);
       } else if (token is TagDirectiveToken) {
         var tagDirective = new TagDirective(token.handle, token.prefix);
         _appendTagDirective(tagDirective, token.span);
         tagDirectives.add(tagDirective);
       }
 
       token = _scanner.advance();
     }
-    
+
     _appendTagDirective(
         new TagDirective("!", "!"),
         token.span.start.pointSpan(),
         allowDuplicates: true);
     _appendTagDirective(
         new TagDirective("!!", "tag:yaml.org,2002:"),
         token.span.start.pointSpan(),
         allowDuplicates: true);
 
     return new Pair(versionDirective, tagDirectives);
@@ skipping 94 matching lines @@
 
   /// Expect nothing.
   static const END = const _State("END");
 
   final String name;
 
   const _State(this.name);
 
   String toString() => name;
 }