more work aligning fasta.Token with analyzer.Token

pkg/analyzer/lib/src/fasta/ast_builder.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.
 
 library fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
 import 'package:analyzer/dart/ast/token.dart' show TokenType;
 import 'package:analyzer/dart/element/element.dart' show Element;
 import 'package:front_end/src/fasta/parser/parser.dart'
     show FormalParameterType, Parser;
 import 'package:front_end/src/fasta/scanner/string_scanner.dart';
 import 'package:front_end/src/fasta/scanner/token.dart'
     show BeginGroupToken, CommentToken, Token;
+import 'package:front_end/src/scanner/token.dart' as analyzer;
 
 import 'package:front_end/src/fasta/errors.dart' show internalError;
 import 'package:front_end/src/fasta/fasta_codes.dart'
     show FastaMessage, codeExpectedExpression, codeExpectedFunctionBody;
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart'
     show Builder, KernelLibraryBuilder, ProcedureBuilder, Scope;
 import 'package:front_end/src/fasta/parser/identifier_context.dart'
     show IdentifierContext;
 import 'package:front_end/src/fasta/quote.dart';
 import 'package:front_end/src/fasta/source/scope_listener.dart'
@@ skipping 177 matching lines @@
     if (context.inLibraryOrPartOfDeclaration) {
       if (!context.isContinuation) {
         push([identifier]);
       } else {
         push(identifier);
       }
     } else if (context == IdentifierContext.enumValueDeclaration) {
       // TODO(paulberry): analyzer's ASTs allow for enumerated values to have
       // metadata, but the spec doesn't permit it.
       List<Annotation> metadata;
-      Comment comment = _toAnalyzerComment(token.precedingCommentTokens);
+      Comment comment = _toAnalyzerComment(token.precedingComments);
       push(ast.enumConstantDeclaration(comment, metadata, identifier));
     } else {
       if (context.isScopeReference) {
         String name = token.lexeme;
         Builder builder = scope.lookup(name, token.charOffset, uri);
         if (builder != null) {
           Element element = elementStore[builder];
           assert(element != null);
           identifier.staticElement = element;
         }
@@ skipping 1630 matching lines @@
   void handleOperatorName(Token operatorKeyword, Token token) {
     debugEvent("OperatorName");
     push(new _OperatorName(operatorKeyword,
         ast.simpleIdentifier(toAnalyzerToken(token), isDeclaration: true)));
   }
 
   @override
   void beginMetadataStar(Token token) {
     debugEvent("beginMetadataStar");
     if (token.precedingComments != null) {
-      push(_toAnalyzerComment(token.precedingCommentTokens));
+      push(_toAnalyzerComment(token.precedingComments));
     } else {
       push(NullValue.Comments);
     }
   }
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
     MethodInvocation invocation = pop();
     SimpleIdentifier constructorName = periodBeforeName != null ? pop() : null;
@@ skipping 10 matching lines @@
   ParameterKind _toAnalyzerParameterKind(FormalParameterType type) {
     if (type == FormalParameterType.POSITIONAL) {
       return ParameterKind.POSITIONAL;
     } else if (type == FormalParameterType.NAMED) {
       return ParameterKind.NAMED;
     } else {
       return ParameterKind.REQUIRED;
     }
   }
 
-  Comment _toAnalyzerComment(Token comments) {
+  Comment _toAnalyzerComment(analyzer.Token comments) {
     if (comments == null) return null;
 
     // This is temporary placeholder code to get tests to pass.
     // TODO(paulberry): after analyzer and fasta token representations are
     // unified, refactor the code in analyzer's parser that handles
     // documentation comments so that it is reusable, and reuse it here.
     // See Parser.parseCommentAndMetadata
     var tokens = <analyzer.Token>[toAnalyzerCommentToken(comments)];
     var references = <CommentReference>[];
     return ast.documentationComment(tokens, references);
@@ skipping 34 matching lines @@
   void discardTypeReplacedWithCommentTypeAssign() {
     pop();
   }
 
   /// Check if the given [token] has a comment token with the given [type],
   /// which should be either [TokenType.GENERIC_METHOD_TYPE_ASSIGN] or
   /// [TokenType.GENERIC_METHOD_TYPE_LIST].  If found, parse the comment
   /// into tokens and inject into the token stream before the [token].
   Token _injectGenericComment(Token token, TokenType type, int prefixLen) {
     if (parseGenericMethodComments) {
-      CommentToken t = token.precedingCommentTokens;
+      CommentToken t = token.precedingComments;
       for (; t != null; t = t.next) {
         if (t.type == type) {
           String code = t.lexeme.substring(prefixLen, t.lexeme.length - 2);
           Token tokens = _scanGenericMethodComment(code, t.offset + prefixLen);
           if (tokens != null) {
             // Remove the token from the comment stream.
             t.remove();
             // Insert the tokens into the stream.
             _injectTokenList(token, tokens);
             return tokens;
@@ skipping 123 matching lines @@
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }