Clean up use of identifier context.

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 222 matching lines @@
   /// `.`.
   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');
+  static const namedArgumentReference = const IdentifierContext._(
+      'namedArgumentReference',
+      allowedInConstantExpression: true);
 
   /// Identifier is a name being declared by a local variable declaration.
   static const localVariableDeclaration = const IdentifierContext._(
       'localVariableDeclaration',
       inDeclaration: true);
 
   /// Identifier is a reference to a label (e.g. `foo` in `break foo;`).
   /// Labels have their own scope.
   static const labelReference = const IdentifierContext._('labelReference');
 
@@ skipping 12 matching lines @@
 
   /// Indicates whether the identifier follows a `.`.
   final bool isContinuation;
 
   /// Indicates whether the identifier should be looked up in the current scope.
   final bool isScopeReference;
 
   /// Indicates whether built-in identifiers are allowed in this context.
   final bool isBuiltInIdentifierAllowed;
 
+  /// Indicated whether the identifier is allowed in a context where constant
+  /// expressions are required.
+  final bool allowedInConstantExpression;
+
   const IdentifierContext._(this._name,
       {this.inDeclaration: false,
       this.inLibraryOrPartOfDeclaration: false,
       this.inSymbol: false,
       this.isContinuation: false,
       this.isScopeReference: false,
-      this.isBuiltInIdentifierAllowed: true});
+      this.isBuiltInIdentifierAllowed: true,
+      bool allowedInConstantExpression})
+      : this.allowedInConstantExpression =
+            // Generally, declarations are legal in constant expressions.  A
+            // continuation doesn't affect constant expressions: if what it's
+            // continuing is a problem, it has already been reported.
+            allowedInConstantExpression ?? (inDeclaration || isContinuation);
 
   String toString() => _name;
 }