flatten token hierarchy

pkg/front_end/lib/src/scanner/token.dart

 // Copyright (c) 2016, 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.
 
 /**
  * Defines the tokens that are produced by the scanner, used by the parser, and
  * referenced from the [AST structure](ast.dart).
  */
 import 'dart:collection';
 
@@ skipping 26 matching lines @@
 class BeginToken extends SimpleToken {
   /**
    * The token that corresponds to this token.
    */
   Token endToken;
 
   /**
    * Initialize a newly created token to have the given [type] at the given
    * [offset].
    */
-  BeginToken(TokenType type, int offset) : super(type, offset) {
+  BeginToken(TokenType type, int offset, [CommentToken precedingComment])
+      : super(type, offset, precedingComment) {
     assert(type == TokenType.LT ||
         type == TokenType.OPEN_CURLY_BRACKET ||
         type == TokenType.OPEN_PAREN ||
         type == TokenType.OPEN_SQUARE_BRACKET ||
         type == TokenType.STRING_INTERPOLATION_EXPRESSION);
   }
 
   @override
-  Token copy() => new BeginToken(type, offset);
+  Token copy() => new BeginToken(type, offset, copyComments(precedingComments));
 
   /**
    * The token that corresponds to this token.
    */
   Token get endGroup => endToken;
 
   /**
    * Set the token that corresponds to this token.
    */
   set endGroup(Token token) {
     endToken = token;
   }
 }
 
 /**
- * A begin token that is preceded by comments.
- */
-class BeginTokenWithComment extends BeginToken implements TokenWithComment {
-  /**
-   * The first comment in the list of comments that precede this token.
-   */
-  @override
-  CommentToken _precedingComment;
-
-  /**
-   * 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
-   * [_precedingComment].
-   */
-  BeginTokenWithComment(TokenType type, int offset, this._precedingComment)
-      : super(type, offset) {
-    _setCommentParent(_precedingComment);
-  }
-
-  @override
-  CommentToken get precedingComments => _precedingComment;
-
-  @override
-  void set precedingComments(CommentToken comment) {
-    _precedingComment = comment;
-    _setCommentParent(_precedingComment);
-  }
-
-  @override
-  Token copy() =>
-      new BeginTokenWithComment(type, offset, copyComments(precedingComments));
-}
-
-/**
  * A token representing a comment.
  */
 class CommentToken extends StringToken {
   /**
    * The token that contains this comment.
    */
-  TokenWithComment parent;
+  SimpleToken parent;
 
   /**
    * Initialize a newly created token to represent a token of the given [type]
    * with the given [value] at the given [offset].
    */
   CommentToken(TokenType type, String value, int offset)
       : super(type, value, offset);
 
   @override
   CommentToken copy() => new CommentToken(type, _value, offset);
@@ skipping 321 matching lines @@
  * A token representing a keyword in the language.
  */
 class KeywordToken extends SimpleToken {
   @override
   final Keyword keyword;
 
   /**
    * Initialize a newly created token to represent the given [keyword] at the
    * given [offset].
    */
-  KeywordToken(this.keyword, int offset) : super(keyword, offset);
+  KeywordToken(this.keyword, int offset, [CommentToken precedingComment])
+      : super(keyword, offset, precedingComment);
 
   @override
-  Token copy() => new KeywordToken(keyword, offset);
+  Token copy() =>
+      new KeywordToken(keyword, offset, copyComments(precedingComments));
 
   @override
   bool get isIdentifier => keyword.isPseudo || keyword.isBuiltIn;
 
   @override
   Object value() => keyword;
 }
 
 /**
- * A keyword token that is preceded by comments.
- */
-class KeywordTokenWithComment extends KeywordToken implements TokenWithComment {
-  /**
-   * The first comment in the list of comments that precede this token.
-   */
-  @override
-  CommentToken _precedingComment;
-
-  /**
-   * 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
-   * [_precedingComment].
-   */
-  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
-  Token copy() => new KeywordTokenWithComment(
-      keyword, offset, copyComments(precedingComments));
-}
-
-/**
  * 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;
 
   @override
   Token next;
 
   /**
+   * The first comment in the list of comments that precede this token.
+   */
+  CommentToken _precedingComment;
+
+  /**
    * Initialize a newly created token to have the given [type] and [offset].
    */
-  SimpleToken(this.type, this.offset);
+  SimpleToken(this.type, this.offset, [this._precedingComment]) {
+    _setCommentParent(_precedingComment);
+  }
 
   @override
   int get charCount => length;
 
   @override
   int get charOffset => offset;
 
   @override
   int get charEnd => end;
 
@@ skipping 21 matching lines @@
   @override
   int get kind => type.kind;
 
   @override
   int get length => lexeme.length;
 
   @override
   String get lexeme => type.lexeme;
 
   @override
-  CommentToken get precedingComments => null;
+  CommentToken get precedingComments => _precedingComment;
+
+  void set precedingComments(CommentToken comment) {
+    _precedingComment = comment;
+    _setCommentParent(_precedingComment);
+  }
 
   @override
   String get stringValue => type.stringValue;
 
   @override
-  Token copy() => new Token(type, offset);
+  Token copy() =>
+      new SimpleToken(type, offset, copyComments(precedingComments));
 
   @override
   Token copyComments(Token token) {
     if (token == null) {
       return null;
     }
     Token head = token.copy();
     Token tail = head;
     token = token.next;
     while (token != null) {
@@ skipping 50 matching lines @@
 class StringToken extends SimpleToken {
   /**
    * The lexeme represented by this token.
    */
   String _value;
 
   /**
    * Initialize a newly created token to represent a token of the given [type]
    * with the given [value] at the given [offset].
    */
-  StringToken(TokenType type, String value, int offset) : super(type, offset) {
+  StringToken(TokenType type, String value, int offset,
+      [CommentToken precedingComment])
+      : super(type, offset, precedingComment) {
     this._value = StringUtilities.intern(value);
   }
 
   @override
   bool get isIdentifier => identical(kind, IDENTIFIER_TOKEN);
 
   @override
   String get lexeme => _value;
 
   @override
-  Token copy() => new StringToken(type, _value, offset);
+  Token copy() =>
+      new StringToken(type, _value, offset, copyComments(precedingComments));
 
   @override
   String value() => _value;
 }
 
 /**
- * A string token that is preceded by comments.
- */
-class StringTokenWithComment extends StringToken implements TokenWithComment {
-  /**
-   * The first comment in the list of comments that precede this token.
-   */
-  CommentToken _precedingComment;
-
-  /**
-   * 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
-  Token copy() => new StringTokenWithComment(
-      type, lexeme, offset, copyComments(precedingComments));
-}
-
-/**
  * A synthetic keyword token.
  */
 class SyntheticKeywordToken extends KeywordToken {
   /**
    * Initialize a newly created token to represent the given [keyword] at the
    * given [offset].
    */
   SyntheticKeywordToken(Keyword keyword, int offset) : super(keyword, offset);
 
   @override
@@ skipping 43 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.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Token implements SyntacticEntity {
   /**
    * Initialize a newly created token to have the given [type] and [offset].
    */
-  factory Token(TokenType type, int offset) = SimpleToken;
+  factory Token(TokenType type, int offset, [CommentToken preceedingComment]) =
+      SimpleToken;
 
   /**
    * Initialize a newly created end-of-file token to have the given [offset].
    */
   factory Token.eof(int offset, [CommentToken precedingComments]) {
-    Token eof = precedingComments == null
-        ? new SimpleToken(TokenType.EOF, offset)
-        : new TokenWithComment(TokenType.EOF, offset, precedingComments);
+    Token eof = new SimpleToken(TokenType.EOF, offset, precedingComments);
     // EOF points to itself so there's always infinite look-ahead.
     eof.previous = eof;
     eof.next = eof;
     return eof;
   }
 
   /**
    * The number of characters parsed by this token.
    */
   int get charCount;
@@ skipping 876 matching lines @@
 
   @override
   String toString() => name;
 
   /**
    * Use [lexeme] instead of this method
    */
   @deprecated
   String get value => lexeme;
 }
-
-/**
- * A normal token that is preceded by comments.
- */
-class TokenWithComment extends SimpleToken {
-  /**
-   * The first comment in the list of comments that precede this token.
-   */
-  CommentToken _precedingComment;
-
-  /**
-   * 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, copyComments(precedingComments));
-}