Parse #operator symbol literals with Fasta.

pkg/front_end/lib/src/fasta/parser/identifier_context.dart

 // Copyright (c) 2017, 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.
 
 /// Information about the parser state which is passed to the listener at the
 /// time an identifier is encountered.
 ///
 /// This can be used by the listener to determine the context in which the
 /// identifier appears; that in turn can help the listener decide how to resolve
 /// the identifier (if the listener is doing resolution).
@@ skipping 182 matching lines @@
           'constructorReferenceContinuationAfterTypeArguments',
           isContinuation: true);
 
   /// Identifier is the declaration of a label (i.e. it is followed by `:` and
   /// then a statement).
   static const labelDeclaration = const IdentifierContext._('labelDeclaration');
 
   /// Identifier is the start of a reference occurring in a literal symbol (e.g.
   /// `foo` in `#foo`).
   static const literalSymbol =
-      const IdentifierContext._('literalSymbol', isScopeReference: true);
+      const IdentifierContext._('literalSymbol', inSymbol: true);

[Paul Berry, 2017/03/06 13:54:06]

Oh yeah, symbols shouldn't be looked up in the local scope.  Thanks for fixing
this bug.

 
   /// Identifier is part of a reference occurring in a literal symbol, but it's
   /// not the first identifier of the reference (e.g. `foo` in `#prefix.foo`).
-  static const literalSymbolContinuation = const IdentifierContext._(
-      'literalSymbolContinuation',
-      isContinuation: true);
+  static const literalSymbolContinuation =
+      const IdentifierContext._('literalSymbolContinuation', inSymbol: true);

[Paul Berry, 2017/03/06 13:54:06]

I think we should keep `isContinuation: true`.  Even though it has no effect,
it's technically correct (see line 241), and it does no harm.

[scheglov, 2017/03/06 15:44:55]

Done.

 
   /// Identifier appears in an expression, and it does not immediately follow a
   /// `.`.
   static const expression =
       const IdentifierContext._('expression', isScopeReference: true);
 
   /// Identifier appears in an expression, and it immediately follows a `.`.
   static const expressionContinuation =
       const IdentifierContext._('expressionContinuation', isContinuation: true);
 
   /// Identifier is a reference to a named argument of a function or method
   /// invocation (e.g. `foo` in `f(foo: 0);`.
   static const namedArgumentReference =
       const IdentifierContext._('namedArgumentReference');
 
   /// Identifier is a name being declared by a local variable declaration.
   static const localVariableDeclaration =
       const IdentifierContext._('localVariableDeclaration');
 
   /// Identifier is a reference to a label (e.g. `foo` in `break foo;`).
   static const labelReference =
       const IdentifierContext._('labelReference', isScopeReference: true);
 
   final String _name;
 
   /// Indicates whether the identifier is within a `library` or `part of`
   /// declaration.
   final bool inLibraryOrPartOfDeclaration;
 
+  /// Indicates whether the identifier is within a symbol literal.
+  final bool inSymbol;
+
   /// Indicates whether the identifier follows a `.`.
   final bool isContinuation;
 
   /// Indicates whether the identifier should be looked up in the current scope.
   final bool isScopeReference;
 
   const IdentifierContext._(this._name,
       {this.inLibraryOrPartOfDeclaration: false,
+      this.inSymbol: false,
       this.isContinuation: false,
       this.isScopeReference: false});
 
   String toString() => _name;
 }