fasta.BeginGroupToken implement analyzer.BeginToken

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 'precedence.dart'
+    show
+        AS_INFO,
+        BAD_INPUT_INFO,
+        EOF_INFO,
+        IDENTIFIER_INFO,
+        IS_INFO,
+        KEYWORD_INFO,
+        MULTI_LINE_COMMENT_INFO,
+        SINGLE_LINE_COMMENT_INFO,
+        PrecedenceInfo;
 
 import 'token_constants.dart' show IDENTIFIER_TOKEN;
 
 import 'string_canonicalizer.dart';
 
 /**
  * A token that doubles as a linked list.
  */
 abstract class Token implements analyzer.TokenWithComment {
   /**
@@ skipping 116 matching lines @@
 
   bool get isBuiltInIdentifier => false;
 
   @override
   bool get isOperator => info.isOperator;
 
   @override
   bool get isUserDefinableOperator => info.isUserDefinableOperator;
 
   @override
-  analyzer.TokenType get type => info;
+  analyzer.TokenType get type {
+    // Analyzer has a different concept of what is a Keyword type.
+    return info == AS_INFO || info == IS_INFO ? KEYWORD_INFO : info;
+  }
 
   @override
   int get offset => charOffset;
 
   @override
   set offset(int newOffset) {
     charOffset = newOffset;
   }
 
   @override
@@ skipping 99 matching lines @@
   @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 {
+class BeginGroupToken extends SymbolToken implements analyzer.BeginToken {
   Token endGroup;
 
   BeginGroupToken(PrecedenceInfo info, int charOffset)
       : super(info, charOffset);
+
+  @override
+  analyzer.Token get endToken => endGroup;
+
+  @override
+  void set endToken(analyzer.Token token) {
+    endGroup = token as Token;

[Paul Berry, 2017/03/21 14:16:01]

This cast shouldn't be required now that the dynamic downcast warning has been
changed to a hint.

[danrubel, 2017/03/21 15:49:24]

Done.

+  }
 }
 
 /**
  * A keyword token.
  */
 class KeywordToken extends Token {
   final Keyword keyword;
 
   KeywordToken(this.keyword, int charOffset) : super(charOffset);
 
@@ skipping 12 matching lines @@
     // fixed.
     return keyword.isBuiltIn || identical("deferred", lexeme);
   }
 
   String toString() => "KeywordToken($lexeme)";
 
   @override
   Token copyWithoutComments() => new KeywordToken(keyword, charOffset);
 
   @override
-  Object value() => keyword;
+  Object value() {
+    // Analyzer has different set of keyword tokens
+    // TODO(danrubel): Remove special case for "deferred" once dartbug.com/29069
+    // is fixed.
+    return isPseudo && !identical("deferred", lexeme) ? lexeme : keyword;
+  }
+
+  @override
+  analyzer.TokenType get type {
+    // Analyzer considers pseudo-keywords to be identifiers
+    // TODO(danrubel): Remove special case for "deferred" once dartbug.com/29069
+    // is fixed.
+    return isPseudo && !identical("deferred", lexeme)
+        ? IDENTIFIER_INFO
+        : KEYWORD_INFO;
+  }
 }
 
 /**
  * A String-valued token. Represents identifiers, string literals,
  * number literals, comments, and error tokens, using the corresponding
  * precedence info.
  */
 class StringToken extends Token implements analyzer.StringToken {
   /**
    * The length threshold above which substring tokens are computed lazily.
@@ skipping 276 matching lines @@
       identical(value, "<=") ||
       identical(value, "<") ||
       identical(value, "&") ||
       identical(value, "^") ||
       identical(value, "|");
 }
 
 bool isTernaryOperator(String value) => identical(value, "[]=");
 
 bool isMinusOperator(String value) => identical(value, "-");