Roll Observatory packages and add a roll script

packages/petitparser/lib/src/dart/grammar.dart

-part of dart;
+part of petitparser.dart;
 
-/**
- * Dart grammar.
- */
+/// Dart grammar.
 class DartGrammar extends GrammarParser {
   DartGrammar() : super(new DartGrammarDefinition());
 }
 
-/**
- * Dart grammar definition.
- *
- * Adapted from [https://code.google.com/p/dart/source/browse/branches/bleeding_edge/dart/language/grammar/Dart.g].
- */
+/// Dart grammar definition.
 class DartGrammarDefinition extends GrammarDefinition {
 
   Parser token(input) {
     if (input is String) {
       input = input.length == 1 ? char(input) : string(input);
     } else if (input is Function) {
       input = ref(input);
     }
     if (input is! Parser && input is TrimmingParser) {
       throw new StateError('Invalid token parser: $input');
     }
-    return input.token().trim(ref(HIDDEN));
+    return input.token().trim(ref(HIDDEN_STUFF));
   }
 
 
   // Copyright (c) 2011, 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.
 
   // -----------------------------------------------------------------
   // Keyword definitions.
   // -----------------------------------------------------------------
@@ skipping 102 matching lines @@
 
   // A method, operator, or constructor (which all should be followed by
   // a block of code).
   methodDeclaration() =>
         ref(factoryConstructorDeclaration)
       | ref(STATIC) & ref(functionDeclaration)
       | ref(specialSignatureDefinition)
       | ref(functionDeclaration) & ref(initializers).optional()
       | ref(namedConstructorDeclaration) & ref(initializers).optional();
 
-// An abstract method/operator, a field, or const constructor (which
-// all should be followed by a semicolon).
+  // An abstract method/operator, a field, or const constructor (which
+  // all should be followed by a semicolon).
   declaration() =>
         ref(constantConstructorDeclaration) & (ref(redirection) | ref(initializers)).optional()
       | ref(functionDeclaration) & ref(redirection)
       | ref(namedConstructorDeclaration) & ref(redirection)
       | ref(ABSTRACT) & ref(specialSignatureDefinition)
       | ref(ABSTRACT) & ref(functionDeclaration)
       | ref(STATIC) & ref(FINAL) & ref(type).optional() & ref(staticFinalDeclarationList)
       | ref(STATIC).optional() & ref(constInitializedVariableDeclaration);
 
   initializers() => ref(token, ':') & ref(superCallOrFieldInitializer) & (ref(token, ',') & ref(superCallOrFieldInitializer)).star();
@@ skipping 77 matching lines @@
 
   assignmentOperator() =>
         ref(token, '=')
       | ref(token, '*=')
       | ref(token, '/=')
       | ref(token, '~/=')
       | ref(token, '%=')
       | ref(token, '+=')
       | ref(token, '-=')
       | ref(token, '<<=')
-      | ref(token, '>') & ref(token, '>') & ref(token, '>') & ref(token, '=')
-      | ref(token, '>') & ref(token, '>') & ref(token, '=')
+      | ref(token, '>>>=')
+      | ref(token, '>>=')
       | ref(token, '&=')
       | ref(token, '^=')
       | ref(token, '|=');
 
   additiveOperator() =>
         ref(token, '+')
       | ref(token, '-');
 
   incrementOperator() =>
         ref(token, '++')
       | ref(token, '--');
 
   shiftOperator() =>
         ref(token, '<<')
-      | ref(token, '>') & ref(token, '>') & ref(token, '>')
-      | ref(token, '>') & ref(token, '>');
+      | ref(token, '>>>')
+      | ref(token, '>>');
 
   relationalOperator() =>
-        ref(token, '>') & ref(token, '=')
+        ref(token, '>=')
       | ref(token, '>')
       | ref(token, '<=')
       | ref(token, '<');
 
   equalityOperator() =>
-        ref(token, '==')
-      | ref(token, '!=')
-      | ref(token, '===')
-      | ref(token, '!==');
+        ref(token, '===')
+      | ref(token, '!==')
+      | ref(token, '==')
+      | ref(token, '!=');
 
   bitwiseOperator() =>
         ref(token, '&')
       | ref(token, '^')
       | ref(token, '|');
 
   formalParameterList() =>
         ref(token, '(') & ref(namedFormalParameters).optional() & ref(token, ')')
       | ref(token, '(') & ref(normalFormalParameter) & ref(normalFormalParameterTail).optional() & ref(token, ')');
 
@@ skipping 32 matching lines @@
   // We have to introduce a separate rule for 'declared' identifiers to
   // allow ANTLR to decide if the first identifier we encounter after
   // final is a type or an identifier. Before this change, we used the
   // production 'finalVarOrType identifier' in numerous places.
   declaredIdentifier() =>
         ref(FINAL) & ref(type).optional() & ref(identifier)
       | ref(VAR) & ref(identifier)
       | ref(type) & ref(identifier)
       ;
 
-  identifier() => ref(token, ref(IDENTIFIER)
-      | ref(ABSTRACT)
-      | ref(ASSERT)
-      | ref(CLASS)
-      | ref(EXTENDS)
-      | ref(FACTORY)
-      | ref(GET)
-      | ref(IMPLEMENTS)
-      | ref(IMPORT)
-      | ref(INTERFACE)
-      | ref(IS)
-      | ref(LIBRARY)
-      | ref(NATIVE)
-      | ref(NEGATE)
-      | ref(OPERATOR)
-      | ref(SET)
-      | ref(SOURCE)
-      | ref(STATIC)
-      | ref(TYPEDEF)
-      );
+  identifier() => ref(token, ref(IDENTIFIER));
 
   qualified() =>
         ref(identifier) & (ref(token, '.') & ref(identifier)).optional()
       ;
 
   type() =>
         ref(qualified) & ref(typeArguments).optional()
       ;
 
   typeArguments() =>
@@ skipping 419 matching lines @@
   SINGLE_LINE_COMMENT() => string('//')
       & ref(NEWLINE).neg().star()
       & ref(NEWLINE).optional()
       ;
 
   MULTI_LINE_COMMENT() => string('/*')
       & (ref(MULTI_LINE_COMMENT) | string('*/').neg()).star() & string('*/')
       ;
 
 }