Parse #operator symbol literals with Fasta.

pkg/front_end/lib/src/fasta/analyzer/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;
@@ skipping 131 matching lines @@
   void endArguments(int count, Token beginToken, Token endToken) {
     debugEvent("Arguments");
     List expressions = popList(count);
     ArgumentList arguments = ast.argumentList(
         toAnalyzerToken(beginToken), expressions, toAnalyzerToken(endToken));
     push(ast.methodInvocation(null, null, null, null, arguments));
   }
 
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
-    String name = token.value;
-    SimpleIdentifier identifier = ast.simpleIdentifier(toAnalyzerToken(token));
+    analyzer.Token analyzerToken = toAnalyzerToken(token);
+
+    if (context.inSymbol) {
+      push(analyzerToken);
+      return;
+    }
+
+    SimpleIdentifier identifier = ast.simpleIdentifier(analyzerToken);
     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;
       // TODO(paulberry): capture doc comments.  See dartbug.com/28851.
       Comment comment = null;
       push(ast.enumConstantDeclaration(comment, metadata, identifier));
     } else {
       if (context.isScopeReference) {
+        String name = token.value;
         Builder builder = scope.lookup(name, token.charOffset, uri);
         if (builder != null) {
           Element element = elementStore[builder];
           assert(element != null);
           identifier.staticElement = element;
         }
       } else if (context == IdentifierContext.classDeclaration) {
         className = identifier.name;
       }
       push(identifier);
@@ skipping 77 matching lines @@
 
   void endCascade() {
     debugEvent("Cascade");
     Expression expression = pop();
     CascadeExpression receiver = pop();
     pop(); // Token.
     receiver.cascadeSections.add(expression);
     push(receiver);
   }
 
+  void handleOperator(Token token) {
+    debugEvent("Operator");
+    push(toAnalyzerToken(token));
+  }
+
   void handleBinaryExpression(Token token) {
     debugEvent("BinaryExpression");
     if (identical(".", token.stringValue) ||
         identical("?.", token.stringValue) ||
         identical("..", token.stringValue)) {
       doDotExpression(token);
     } else {
       Expression right = pop();
       Expression left = pop();
       push(ast.binaryExpression(left, toAnalyzerToken(token), right));
@@ skipping 204 matching lines @@
         toAnalyzerToken(beginToken), entries, toAnalyzerToken(endToken)));
   }
 
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
     Expression value = pop();
     Expression key = pop();
     push(ast.mapLiteralEntry(key, toAnalyzerToken(colon), value));
   }
 
-  void endLiteralSymbol(Token hashToken, int identifierCount) {
+  void endLiteralSymbol(Token hashToken, int tokenCount) {
     debugEvent("LiteralSymbol");
-    List<analyzer.Token> components = new List<analyzer.Token>(identifierCount);
-    for (int i = identifierCount - 1; i >= 0; i--) {
-      SimpleIdentifier identifier = pop();
-      components[i] = identifier.token;
-    }
+    List<analyzer.Token> components = popList(tokenCount);
     push(ast.symbolLiteral(toAnalyzerToken(hashToken), components));
   }
 
   @override
   void handleSuperExpression(Token token) {
     debugEvent("SuperExpression");
     push(ast.superExpression(toAnalyzerToken(token)));
   }
 
   @override
@@ skipping 941 matching lines @@
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }