Translate Java's @Override into Dart's @override.

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';
@@ skipping 170 matching lines @@
   /**
    * Initialize a newly created error code to have the given message and correction.
    *
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   ScannerErrorCode.con2(String name, int ordinal, this.message, String correction) : super(name, ordinal) {
     this.correction10 = correction;
   }
 
+  @override
   String get correction => correction10;
 
+  @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
+  @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
 
 /**
  * Instances of the class `SubSequenceReader` implement a [CharacterReader] that reads
  * characters from a character sequence, but adds a delta when reporting the current character
  * offset so that the character sequence can be a subsequence from a larger sequence.
  */
 class SubSequenceReader extends CharSequenceReader {
   /**
    * The offset from the beginning of the file to the beginning of the source being scanned.
    */
   int _offsetDelta = 0;
 
   /**
    * Initialize a newly created reader to read the characters in the given sequence.
    *
    * @param sequence the sequence from which characters will be read
    * @param offsetDelta the offset from the beginning of the file to the beginning of the source
    *          being scanned
    */
   SubSequenceReader(String sequence, int offsetDelta) : super(sequence) {
     this._offsetDelta = offsetDelta;
   }
 
+  @override
   int get offset => _offsetDelta + super.offset;
 
+  @override
   String getString(int start, int endDelta) => super.getString(start - _offsetDelta, endDelta);
 
+  @override
   void set offset(int offset) {
     super.offset = offset - _offsetDelta;
   }
 }
 
 /**
  * Instances of the class `TokenWithComment` represent a string token that is preceded by
  * comments.
  */
 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.
    *
    * @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
    */
   StringTokenWithComment(TokenType type, String value, int offset, Token precedingComment) : super(type, value, offset) {
     this._precedingComment = precedingComment;
   }
 
+  @override
   Token copy() => new StringTokenWithComment(type, lexeme, offset, copyComments(_precedingComment));
 
+  @override
   Token get precedingComments => _precedingComment;
 
+  @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
@@ skipping 236 matching lines @@
    * Initialize a newly created reader to read the characters in the given sequence.
    *
    * @param sequence the sequence from which characters will be read
    */
   CharSequenceReader(String sequence) {
     this._sequence = sequence;
     this._stringLength = sequence.length;
     this._charOffset = -1;
   }
 
+  @override
   int advance() {
     if (_charOffset + 1 >= _stringLength) {
       return -1;
     }
     return _sequence.codeUnitAt(++_charOffset);
   }
 
+  @override
   int get offset => _charOffset;
 
+  @override
   String getString(int start, int endDelta) => _sequence.substring(start, _charOffset + 1 + endDelta).toString();
 
+  @override
   int peek() {
     if (_charOffset + 1 >= _sequence.length) {
       return -1;
     }
     return _sequence.codeUnitAt(_charOffset + 1);
   }
 
+  @override
   void set offset(int offset) {
     _charOffset = offset;
   }
 }
 
 /**
  * Synthetic `StringToken` represent a token whose value is independent of it's type.
  */
 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);
 
+  @override
   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.
  */
 class IncrementalScanner extends Scanner {
   /**
    * The reader used to access the characters in the source.
@@ skipping 1301 matching lines @@
    * 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._value = StringUtilities.intern(value);
   }
 
+  @override
   Token copy() => new StringToken(type, _value, offset);
 
+  @override
   String get lexeme => _value;
 
+  @override
   String value() => _value;
 }
 
 /**
  * Instances of the class `TokenWithComment` represent a normal token that is preceded by
  * comments.
  */
 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;
   }
 
+  @override
   Token copy() => new TokenWithComment(type, offset, _precedingComment);
 
+  @override
   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.
  */
 class Token {
   /**
    * The type of the token.
@@ skipping 127 matching lines @@
    * previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   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.
    *
    * @return the value of this token
    */
   Object value() => type.lexeme;
 
@@ skipping 90 matching lines @@
    * 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
    */
   BeginTokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
 
+  @override
   Token copy() => new BeginTokenWithComment(type, offset, copyComments(_precedingComment));
 
+  @override
   Token get precedingComments => _precedingComment;
 
+  @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
 /**
  * Instances of the class `KeywordToken` represent a keyword in the language.
  */
 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);
 
+  @override
   Token copy() => new KeywordToken(keyword, offset);
 
+  @override
   String get lexeme => keyword.syntax;
 
+  @override
   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 ('[').
  */
 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)));
   }
 
+  @override
   Token copy() => new BeginToken(type, offset);
 }
 
 /**
  * The enumeration `TokenClass` represents classes (or groups) of tokens with a similar use.
  */
 class TokenClass extends Enum<TokenClass> {
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
@@ skipping 128 matching lines @@
    * comments reachable from the given comment.
    *
    * @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
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   KeywordTokenWithComment(Keyword keyword, int offset, Token precedingComment) : super(keyword, offset) {
     this._precedingComment = precedingComment;
   }
 
+  @override
   Token copy() => new KeywordTokenWithComment(keyword, offset, copyComments(_precedingComment));
 
+  @override
   Token get precedingComments => _precedingComment;
 
+  @override
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
 
@@ skipping 332 matching lines @@
    * Return `true` if this token type represents an operator that can be defined by users.
    *
    * @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);
 
+  @override
   String toString() => "-eof-";
 }