fasta.Token implement analyzer.Token

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

 // 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.
 
 library fasta.scanner.token;
 
 import '../../scanner/token.dart' as analyzer;
 
 import 'keyword.dart' show Keyword;
 
 import 'precedence.dart' show BAD_INPUT_INFO, EOF_INFO, PrecedenceInfo;
 
 import 'token_constants.dart' show IDENTIFIER_TOKEN;
 
 import 'string_canonicalizer.dart';
 
 /**
  * A token that doubles as a linked list.
  */
-abstract class Token {
+abstract class Token implements analyzer.Token {
   /**
    * The character offset of the start of this token within the source text.
    */
-  final int charOffset;
+  int charOffset;
 
   Token(this.charOffset);
 
   /**
    * The next token in the token stream.
    */
   Token next;
 
   /**
    * The previous token in the token stream.
@@ skipping 88 matching lines @@
     }
   }
 
   /// The character offset of the end of this token within the source text.
   int get charEnd => charOffset + charCount;
 
   bool get isEof => false;
 
   bool get isBuiltInIdentifier => false;
 
+  @override
   bool get isOperator => info.isOperator;
 
+  @override
   bool get isUserDefinableOperator => info.isUserDefinableOperator;
 
+  @override
   analyzer.TokenType get type => info;
 
+  @override
   int get offset => charOffset;
+
+  @override
+  set offset(int newOffset) {
+    charOffset = newOffset;
+  }
+
+  @override
+  int get length => charCount;
+
+  @override
+  int get end => charEnd;
+
+  @override
+  analyzer.Token get previous => previousToken;
+
+  @override
+  set previous(analyzer.Token newToken) {
+    previousToken = newToken as Token;
+  }
+
+  @override
+  void applyDelta(int delta) {
+    charOffset += delta;
+    Token token = precedingComments;
+    while (token != null) {
+      token.applyDelta(delta);
+      token = token.next;
+    }
+  }
+
+  @override
+  analyzer.Token copy() {
+    return copyWithoutComments()
+      ..precedingComments = copyComments(precedingComments) as Token;

[ahe, 2017/03/20 12:32:48]

Could you remove the casts from this file? As far as I know, downcasts aren't a
warning anymore. Perhaps you're using an old version of the analyzer.

+  }
+
+  @override
+  analyzer.Token copyComments(analyzer.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 a copy of the receiver without [preceedingComments].
+  Token copyWithoutComments();
+
+  @override
+  bool get isSynthetic => charCount == 0;
+
+  @override
+  analyzer.Keyword get keyword => null;
+
+  @override
+  bool matchesAny(List<analyzer.TokenType> types) {
+    for (analyzer.TokenType type in types) {
+      if (this.type == type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
+  analyzer.Token setNext(analyzer.Token token) {
+    next = token as Token;
+    next.previousToken = this;
+    return token;
+  }
+
+  @override
+  analyzer.Token setNextWithoutSettingPrevious(analyzer.Token token) {
+    next = token as Token;
+    return token;
+  }
+
+  @override
+  Object value() => lexeme;
 }
 
 /**
  * A [SymbolToken] represents the symbol in its precedence info.
  * Also used for end of file with EOF_INFO.
  */
 class SymbolToken extends Token {
   final PrecedenceInfo info;
 
   SymbolToken(this.info, int charOffset) : super(charOffset);
 
   String get lexeme => info.value;
 
   String get stringValue => info.value;
 
   bool isIdentifier() => false;
 
   String toString() => "SymbolToken($lexeme)";
 
   bool get isEof => info == EOF_INFO;
+
+  @override
+  Token copyWithoutComments() => new SymbolToken(info, charOffset);
 }
 
 /**
  * A [BeginGroupToken] represents a symbol that may be the beginning of
  * a pair of brackets, i.e., ( { [ < or ${
  * The [endGroup] token points to the matching closing bracked in case
  * it can be identified during scanning.
  */
 class BeginGroupToken extends SymbolToken {
   Token endGroup;
@@ skipping 20 matching lines @@
 
   bool get isPseudo => keyword.isPseudo;
 
   bool get isBuiltInIdentifier {
     // TODO(ahe): Remove special case for "deferred" once dartbug.com/29069 is
     // fixed.
     return keyword.isBuiltIn || identical("deferred", lexeme);
   }
 
   String toString() => "KeywordToken($lexeme)";
+
+  @override
+  Token copyWithoutComments() => new KeywordToken(keyword, charOffset);
+
+  @override
+  Object value() => keyword;
 }
 
 /**
  * A String-valued token. Represents identifiers, string literals,
  * number literals, comments, and error tokens, using the corresponding
  * precedence info.
  */
 class StringToken extends Token {
   /**
    * The length threshold above which substring tokens are computed lazily.
@@ skipping 45 matching lines @@
       bool asciiOnly, int charOffset)
       : super(charOffset) {
     int length = end - start;
     if (length <= LAZY_THRESHOLD) {
       valueOrLazySubstring = decodeUtf8(data, start, end, asciiOnly);
     } else {
       valueOrLazySubstring = new LazySubstring(data, start, length, asciiOnly);
     }
   }
 
+  StringToken._(this.info, this.valueOrLazySubstring, int charOffset)

[ahe, 2017/03/20 12:32:48]

I'd prefer a non-private name for this.

+      : super(charOffset);
+
   String get lexeme {
     if (valueOrLazySubstring is String) {
       return valueOrLazySubstring;
     } else {
       assert(valueOrLazySubstring is LazySubstring);
       var data = valueOrLazySubstring.data;
       int start = valueOrLazySubstring.start;
       int end = start + valueOrLazySubstring.length;
       if (data is String) {
         valueOrLazySubstring = canonicalizedString(
@@ skipping 17 matching lines @@
 
   static String canonicalizedString(
       String s, int start, int end, bool canonicalize) {
     if (!canonicalize) return s;
     return canonicalizer.canonicalize(s, start, end, false);
   }
 
   static String decodeUtf8(List<int> data, int start, int end, bool asciiOnly) {
     return canonicalizer.canonicalize(data, start, end, asciiOnly);
   }
+
+  @override
+  Token copyWithoutComments() =>
+      new StringToken._(info, valueOrLazySubstring, charOffset);
 }
 
 /**
  * This class represents the necessary information to compute a substring
  * lazily. The substring can either originate from a string or from
  * a [:List<int>:] of UTF-8 bytes.
  */
 abstract class LazySubstring {
   /** The original data, either a string or a List<int> */
   get data;
@@ skipping 78 matching lines @@
       identical(value, "<=") ||
       identical(value, "<") ||
       identical(value, "&") ||
       identical(value, "^") ||
       identical(value, "|");
 }
 
 bool isTernaryOperator(String value) => identical(value, "[]=");
 
 bool isMinusOperator(String value) => identical(value, "-");