Update and analyzer snapshot with AST -> Ast rename.

pkg/analyzer/lib/src/generated/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.scanner;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
 import 'instrumentation.dart';
 import 'utilities_collection.dart' show TokenMap;
 
 /**
  * Instances of the abstract class `KeywordState` represent a state in a state machine used to
  * scan keywords.
- *
- * @coverage dart.engine.parser
  */
 class KeywordState {
   /**
    * An empty transition table used by leaf states.
    */
   static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>(26);
 
   /**
    * The initial state in the state machine.
    */
@@ skipping 100 matching lines @@
    *
    * @param c the character used to transition from this state to another state
    * @return the state that follows this state on a transition of the given character
    */
   KeywordState next(int c) => _table[c - 0x61];
 }
 
 /**
  * The enumeration `ScannerErrorCode` defines the error codes used for errors detected by the
  * scanner.
- *
- * @coverage dart.engine.parser
  */
 class ScannerErrorCode extends Enum<ScannerErrorCode> implements ErrorCode {
   static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode.con1('ILLEGAL_CHARACTER', 0, "Illegal character %x");
 
   static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode.con1('MISSING_DIGIT', 1, "Decimal digit expected");
 
   static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode.con1('MISSING_HEX_DIGIT', 2, "Hexidecimal digit expected");
 
   static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode.con1('MISSING_QUOTE', 3, "Expected quote (' or \")");
 
@@ skipping 71 matching lines @@
   String getString(int start, int endDelta) => super.getString(start - _offsetDelta, endDelta);
 
   void set offset(int offset) {
     super.offset = offset - _offsetDelta;
   }
 }
 
 /**
  * Instances of the class `TokenWithComment` represent a string token that is preceded by
  * comments.
- *
- * @coverage dart.engine.parser
  */
 class StringTokenWithComment extends StringToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
@@ skipping 15 matching lines @@
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
 /**
  * The enumeration `Keyword` defines the keywords in the Dart programming language.
- *
- * @coverage dart.engine.parser
  */
 class Keyword extends Enum<Keyword> {
   static final Keyword ASSERT = new Keyword.con1('ASSERT', 0, "assert");
 
   static final Keyword BREAK = new Keyword.con1('BREAK', 1, "break");
 
   static final Keyword CASE = new Keyword.con1('CASE', 2, "case");
 
   static final Keyword CATCH = new Keyword.con1('CATCH', 3, "catch");
 
@@ skipping 249 matching lines @@
     return _sequence.codeUnitAt(_charOffset + 1);
   }
 
   void set offset(int offset) {
     _charOffset = offset;
   }
 }
 
 /**
  * Synthetic `StringToken` represent a token whose value is independent of it's type.
- *
- * @coverage dart.engine.parser
  */
 class SyntheticStringToken extends StringToken {
   /**
    * Initialize a newly created token to represent a token of the given type with the given value.
    *
    * @param type the type of the token
    * @param value the lexeme represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   SyntheticStringToken(TokenType type, String value, int offset) : super(type, value, offset);
 
   bool get isSynthetic => true;
 }
 
 /**
  * Instances of the class `IncrementalScanner` implement a scanner that scans a subset of a
  * string and inserts the resulting tokens into the middle of an existing token stream.
- *
- * @coverage dart.engine.parser
  */
 class IncrementalScanner extends Scanner {
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
   /**
    * A map from tokens that were copied to the copies of the tokens.
    */
@@ skipping 205 matching lines @@
 }
 
 /**
  * The class `Scanner` implements a scanner for Dart code.
  *
  * The lexical structure of Dart is ambiguous without knowledge of the context in which a token is
  * being scanned. For example, without context we cannot determine whether source of the form "<<"
  * should be scanned as a single left-shift operator or as two left angle brackets. This scanner
  * does not have any context, so it always resolves such conflicts by scanning the longest possible
  * token.
- *
- * @coverage dart.engine.parser
  */
 class Scanner {
   /**
    * The source being scanned.
    */
   final Source source;
 
   /**
    * The reader used to access the characters in the source.
    */
@@ skipping 1052 matching lines @@
     } else {
       appendToken2(TokenType.TILDE);
       return next;
     }
   }
 }
 
 /**
  * Instances of the class `StringToken` represent a token whose value is independent of it's
  * type.
- *
- * @coverage dart.engine.parser
  */
 class StringToken extends Token {
   /**
    * The lexeme represented by this token.
    */
   String _value2;
 
   /**
    * Initialize a newly created token to represent a token of the given type with the given value.
    *
    * @param type the type of the token
    * @param value the lexeme represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   StringToken(TokenType type, String value, int offset) : super(type, offset) {
     this._value2 = StringUtilities.intern(value);
   }
 
   Token copy() => new StringToken(type, _value2, offset);
 
   String get lexeme => _value2;
 
   String value() => _value2;
 }
 
 /**
  * Instances of the class `TokenWithComment` represent a normal token that is preceded by
  * comments.
- *
- * @coverage dart.engine.parser
  */
 class TokenWithComment extends Token {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   TokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
 
   Token copy() => new TokenWithComment(type, offset, _precedingComment);
 
   Token get precedingComments => _precedingComment;
 }
 
 /**
  * Instances of the class `Token` represent a token that was scanned from the input. Each
  * token knows which token follows it, acting as the head of a linked list of tokens.
- *
- * @coverage dart.engine.parser
  */
 class Token {
   /**
    * The type of the token.
    */
   final TokenType type;
 
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
@@ skipping 197 matching lines @@
    * the initial offset and one (1) past the end of the source code.
    *
    * @param offset the new offset in the source
    */
   void set offset(int offset);
 }
 
 /**
  * Instances of the class `BeginTokenWithComment` represent a begin token that is preceded by
  * comments.
- *
- * @coverage dart.engine.parser
  */
 class BeginTokenWithComment extends BeginToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
@@ skipping 15 matching lines @@
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
 /**
  * Instances of the class `KeywordToken` represent a keyword in the language.
- *
- * @coverage dart.engine.parser
  */
 class KeywordToken extends Token {
   /**
    * The keyword being represented by this token.
    */
   final Keyword keyword;
 
   /**
    * Initialize a newly created token to represent the given keyword.
    *
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   KeywordToken(this.keyword, int offset) : super(TokenType.KEYWORD, offset);
 
   Token copy() => new KeywordToken(keyword, offset);
 
   String get lexeme => keyword.syntax;
 
   Keyword value() => keyword;
 }
 
 /**
  * Instances of the class `BeginToken` represent the opening half of a grouping pair of
  * tokens. This is used for curly brackets ('{'), parentheses ('('), and square brackets ('[').
- *
- * @coverage dart.engine.parser
  */
 class BeginToken extends Token {
   /**
    * The token that corresponds to this token.
    */
   Token endToken;
 
   /**
    * Initialize a newly created token representing the opening half of a grouping pair of tokens.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   BeginToken(TokenType type, int offset) : super(type, offset) {
     assert((identical(type, TokenType.OPEN_CURLY_BRACKET) || identical(type, TokenType.OPEN_PAREN) || identical(type, TokenType.OPEN_SQUARE_BRACKET) || identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)));
   }
 
   Token copy() => new BeginToken(type, offset);
 }
 
 /**
  * The enumeration `TokenClass` represents classes (or groups) of tokens with a similar use.
- *
- * @coverage dart.engine.parser
  */
 class TokenClass extends Enum<TokenClass> {
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
   static final TokenClass NO_CLASS = new TokenClass.con1('NO_CLASS', 0);
 
   /**
    * A value used to indicate that the token type is an additive operator.
    */
@@ skipping 104 matching lines @@
    * an operator.
    *
    * @return the precedence of tokens of this class
    */
   int get precedence => _precedence;
 }
 
 /**
  * Instances of the class `KeywordTokenWithComment` implement a keyword token that is preceded
  * by comments.
- *
- * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to to represent the given keyword and to be preceded by the
    * comments reachable from the given comment.
@@ skipping 16 matching lines @@
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
- *
- * @coverage dart.engine.parser
  */
 class TokenType extends Enum<TokenType> {
   /**
    * The type of the token that marks the end of the input.
    */
   static final TokenType EOF = new TokenType_EOF('EOF', 0, null, "");
 
   static final TokenType DOUBLE = new TokenType.con1('DOUBLE', 1);
 
   static final TokenType HEXADECIMAL = new TokenType.con1('HEXADECIMAL', 2);
@@ skipping 321 matching lines @@
    * @return `true` if this token type represents an operator that can be defined by users
    */
   bool get isUserDefinableOperator => identical(_lexeme, "==") || identical(_lexeme, "~") || identical(_lexeme, "[]") || identical(_lexeme, "[]=") || identical(_lexeme, "*") || identical(_lexeme, "/") || identical(_lexeme, "%") || identical(_lexeme, "~/") || identical(_lexeme, "+") || identical(_lexeme, "-") || identical(_lexeme, "<<") || identical(_lexeme, ">>") || identical(_lexeme, ">=") || identical(_lexeme, ">") || identical(_lexeme, "<=") || identical(_lexeme, "<") || identical(_lexeme, "&") || identical(_lexeme, "^") || identical(_lexeme, "|");
 }
 
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
 
   String toString() => "-eof-";
 }