Move scanner out of generated and clean up imports

pkg/analyzer/lib/src/dart/ast/token.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 analyzer.src.dart.ast.token;
 
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 
 /**
@@ skipping 33 matching lines @@
   /**
    * Initialize a newly created token to have the given [type] at the given
    * [offset] and to be preceded by the comments reachable from the given
    * [comment].
    */
   BeginTokenWithComment(TokenType type, int offset, this._precedingComment)
       : super(type, offset) {
     _setCommentParent(_precedingComment);
   }
 
+  @override
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
@@ skipping 93 matching lines @@
   /**
    * Initialize a newly created token to to represent the given [keyword] at the
    * given [offset] and to be preceded by the comments reachable from the given
    * [comment].
    */
   KeywordTokenWithComment(Keyword keyword, int offset, this._precedingComment)
       : super(keyword, offset) {
     _setCommentParent(_precedingComment);
   }
 
+  @override
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
@@ skipping 10 matching lines @@
 }
 
 /**
  * A token that was scanned from the input. Each token knows which tokens
  * precede and follow it, acting as a link in a doubly linked list of tokens.
  */
 class SimpleToken implements Token {
   /**
    * The type of the token.
    */
+  @override
   final TokenType type;
 
   /**
    * The offset from the beginning of the file to the first character in the
    * token.
    */
+  @override
   int offset = 0;
 
   /**
    * The previous token in the token stream.
    */
+  @override
   Token previous;
 
   /**
    * The next token in the token stream.
    */
   Token _next;
 
   /**
    * Initialize a newly created token to have the given [type] and [offset].
    */
   SimpleToken(this.type, this.offset);
 
-  /**
-   * Return the offset from the beginning of the file to the character after the
-   * last character of the token.
-   */
+  @override
   int get end => offset + length;
 
-  /**
-   * Return `true` if this token represents an operator.
-   */
+  @override
   bool get isOperator => type.isOperator;
 
-  /**
-   * Return `true` if this token is a synthetic token. A synthetic token is a
-   * token that was introduced by the parser in order to recover from an error
-   * in the code.
-   */
+  @override
   bool get isSynthetic => length == 0;
 
-  /**
-   * Return `true` if this token represents an operator that can be defined by
-   * users.
-   */
+  @override
   bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
-  /**
-   * Return the number of characters in the node's source range.
-   */
+  @override
   int get length => lexeme.length;
 
-  /**
-   * Return the lexeme that represents this token.
-   */
+  @override
   String get lexeme => type.lexeme;
 
-  /**
-   * Return the next token in the token stream.
-   */
+  @override
   Token get next => _next;
 
-  /**
-   * Return the first comment in the list of comments that precede this token,
-   * or `null` if there are no comments preceding this token. Additional
-   * comments can be reached by following the token stream using [next] until
-   * `null` is returned.
-   *
-   * For example, if the original contents were `/* one */ /* two */ id`, then
-   * the first preceding comment token will have a lexeme of `/* one */` and
-   * the next comment token will have a lexeme of `/* two */`.
-   */
+  @override
   CommentToken get precedingComments => null;
 
-  /**
-   * Apply (add) the given [delta] to this token's offset.
-   */
+  @override
   void applyDelta(int delta) {
     offset += delta;
   }
 
-  /**
-   * Return a newly created token that is a copy of this token but that is not a
-   * part of any token stream.
-   */
+  @override
   Token copy() => new Token(type, offset);
 
-  /**
-   * Copy a linked list of comment tokens identical to the given comment tokens.
-   */
+  @override
   Token copyComments(Token token) {
     if (token == null) {
       return null;
     }
     Token head = token.copy();
     Token tail = head;
     token = token.next;
     while (token != null) {
       tail = tail.setNext(token.copy());
       token = token.next;
     }
     return head;
   }
 
-  /**
-   * Return `true` if this token has any one of the given [types].
-   */
+  @override
   bool matchesAny(List<TokenType> types) {
     for (TokenType type in types) {
       if (this.type == type) {
         return true;
       }
     }
     return false;
   }
 
-  /**
-   * Set the next token in the token stream to the given [token]. This has the
-   * side-effect of setting this token to be the previous token for the given
-   * token. Return the token that was passed in.
-   */
+  @override
   Token setNext(Token token) {
     _next = token;
     token.previous = this;
     return token;
   }
 
-  /**
-   * Set the next token in the token stream to the given token without changing
-   * which token is the previous token for the given token. Return the token
-   * that was passed in.
-   */
+  @override
   Token setNextWithoutSettingPrevious(Token token) {
     _next = token;
     return token;
   }
 
   @override
   String toString() => lexeme;
 
-  /**
-   * Return the value of this token. For keyword tokens, this is the keyword
-   * associated with the token, for other tokens it is the lexeme associated
-   * with the token.
-   */
+  @override
   Object value() => type.lexeme;
 
   /**
    * Sets the `parent` property to `this` for the given [comment] and all the
    * next tokens.
    */
   void _setCommentParent(CommentToken comment) {
     while (comment != null) {
       comment.parent = this;
       comment = comment.next;
@@ skipping 41 matching lines @@
    * Initialize a newly created token to have the given [type] at the given
    * [offset] and to be preceded by the comments reachable from the given
    * [comment].
    */
   StringTokenWithComment(
       TokenType type, String value, int offset, this._precedingComment)
       : super(type, value, offset) {
     _setCommentParent(_precedingComment);
   }
 
+  @override
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
@@ skipping 163 matching lines @@
   /**
    * Initialize a newly created token to have the given [type] at the given
    * [offset] and to be preceded by the comments reachable from the given
    * [comment].
    */
   TokenWithComment(TokenType type, int offset, this._precedingComment)
       : super(type, offset) {
     _setCommentParent(_precedingComment);
   }
 
+  @override
   CommentToken get precedingComments => _precedingComment;
 
   void set precedingComments(CommentToken comment) {
     _precedingComment = comment;
     _setCommentParent(_precedingComment);
   }
 
   @override
   Token copy() => new TokenWithComment(type, offset, precedingComments);
 }