Version 2.14.0-137.0.dev

Merge commit 'd8bbd356a9fceee8bf675c5f6e0f8c7014a1e3a8' into 'dev'
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
index 7a92c54..2649c47 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
@@ -2,8 +2,6 @@
 // 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.
 
-// @dart = 2.9
-
 part of 'constant_evaluator.dart';
 
 abstract class _ListOrSetConstantBuilder<L extends Expression> {
@@ -23,7 +21,7 @@
   ///
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant add(Expression element) {
+  AbortConstant? add(Expression element) {
     Constant constant = evaluator._evaluateSubexpression(element);
     if (constant is AbortConstant) return constant;
     if (evaluator.shouldBeUnevaluated) {
@@ -37,7 +35,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addSpread(Expression spreadExpression) {
+  AbortConstant? addSpread(Expression spreadExpression) {
     Constant constant = evaluator._evaluateSubexpression(spreadExpression);
     if (constant is AbortConstant) return constant;
     Constant spread = evaluator.unlower(constant);
@@ -73,7 +71,7 @@
             spreadExpression, messageConstEvalNotListOrSetInSpread);
       }
       for (Constant entry in entries) {
-        AbortConstant error = addConstant(entry, spreadExpression);
+        AbortConstant? error = addConstant(entry, spreadExpression);
         if (error != null) return error;
       }
     }
@@ -82,7 +80,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addConstant(Constant constant, TreeNode context);
+  AbortConstant? addConstant(Constant constant, TreeNode context);
 
   Constant build();
 }
@@ -104,10 +102,10 @@
       new ListLiteral(elements, isConst: true);
 
   @override
-  AbortConstant addConstant(Constant constant, TreeNode context) {
+  AbortConstant? addConstant(Constant constant, TreeNode context) {
     List<Constant> lastPart;
     if (parts.last is List<Constant>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<Constant>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <Constant>[]);
@@ -122,11 +120,12 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
+      List<Constant> entries = parts.single as List<Constant>;
       if (isMutable) {
-        return new MutableListConstant(elementType, parts.single);
+        return new MutableListConstant(elementType, entries);
       }
       return evaluator
-          .lowerListConstant(new ListConstant(elementType, parts.single));
+          .lowerListConstant(new ListConstant(elementType, entries));
     }
     // TODO(kallentu): Handle partially evaluated [isMutable] lists.
     List<Expression> lists = <Expression>[];
@@ -158,7 +157,7 @@
       new SetLiteral(elements, isConst: true);
 
   @override
-  AbortConstant addConstant(Constant constant, TreeNode context) {
+  AbortConstant? addConstant(Constant constant, TreeNode context) {
     if (!evaluator.hasPrimitiveEqual(constant)) {
       return evaluator.createErrorConstant(
           context,
@@ -184,7 +183,7 @@
 
     List<Constant> lastPart;
     if (parts.last is List<Constant>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<Constant>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <Constant>[]);
@@ -199,7 +198,7 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
-      List<Constant> entries = parts.single;
+      List<Constant> entries = parts.single as List<Constant>;
       SetConstant result = new SetConstant(elementType, entries);
       return evaluator.lowerSetConstant(result);
     }
@@ -239,7 +238,7 @@
   ///
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant add(MapLiteralEntry element) {
+  AbortConstant? add(MapLiteralEntry element) {
     Constant key = evaluator._evaluateSubexpression(element.key);
     if (key is AbortConstant) return key;
     Constant value = evaluator._evaluateSubexpression(element.value);
@@ -259,7 +258,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addSpread(Expression spreadExpression) {
+  AbortConstant? addSpread(Expression spreadExpression) {
     Constant constant = evaluator._evaluateSubexpression(spreadExpression);
     if (constant is AbortConstant) return constant;
     Constant spread = evaluator.unlower(constant);
@@ -274,12 +273,12 @@
       // Fully evaluated spread
       if (spread is MapConstant) {
         for (ConstantMapEntry entry in spread.entries) {
-          AbortConstant error = addConstant(
+          AbortConstant? error = addConstant(
               entry.key, entry.value, spreadExpression, spreadExpression);
           if (error != null) return error;
         }
       } else if (evaluator.backend.isLoweredMapConstant(spread)) {
-        AbortConstant error;
+        AbortConstant? error;
         evaluator.backend.forEachLoweredMapConstantEntry(spread,
             (Constant key, Constant value) {
           error ??= addConstant(key, value, spreadExpression, spreadExpression);
@@ -296,11 +295,11 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addConstant(Constant key, Constant value, TreeNode keyContext,
+  AbortConstant? addConstant(Constant key, Constant value, TreeNode keyContext,
       TreeNode valueContext) {
     List<ConstantMapEntry> lastPart;
     if (parts.last is List<ConstantMapEntry>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<ConstantMapEntry>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <ConstantMapEntry>[]);
@@ -337,8 +336,9 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
+      List<ConstantMapEntry> entries = parts.single as List<ConstantMapEntry>;
       return evaluator
-          .lowerMapConstant(new MapConstant(keyType, valueType, parts.single));
+          .lowerMapConstant(new MapConstant(keyType, valueType, entries));
     }
     List<Expression> maps = <Expression>[];
     for (Object part in parts) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index df03f0b..2956b23 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -2,8 +2,6 @@
 // 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.
 
-// @dart = 2.9
-
 /// This library implements a kernel2kernel constant evaluation transformation.
 ///
 /// Even though it is expected that the frontend does not emit kernel AST which
@@ -84,17 +82,22 @@
     Map<String, String> environmentDefines,
     ErrorReporter errorReporter,
     EvaluationMode evaluationMode,
-    {bool evaluateAnnotations,
-    bool desugarSets,
-    bool enableTripleShift,
-    bool enableConstFunctions,
-    bool errorOnUnevaluatedConstant,
-    CoreTypes coreTypes,
-    ClassHierarchy hierarchy}) {
+    {required bool evaluateAnnotations,
+    required bool desugarSets,
+    required bool enableTripleShift,
+    required bool enableConstFunctions,
+    required bool errorOnUnevaluatedConstant,
+    CoreTypes? coreTypes,
+    ClassHierarchy? hierarchy}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(desugarSets != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   coreTypes ??= new CoreTypes(component);
   hierarchy ??= new ClassHierarchy(component, coreTypes);
@@ -118,13 +121,17 @@
     TypeEnvironment typeEnvironment,
     ErrorReporter errorReporter,
     EvaluationMode evaluationMode,
-    {bool evaluateAnnotations,
-    bool enableTripleShift,
-    bool enableConstFunctions,
-    bool errorOnUnevaluatedConstant}) {
+    {required bool evaluateAnnotations,
+    required bool enableTripleShift,
+    required bool enableConstFunctions,
+    required bool errorOnUnevaluatedConstant}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   final ConstantsTransformer constantsTransformer = new ConstantsTransformer(
       backend,
@@ -153,9 +160,13 @@
     bool enableTripleShift: false,
     bool enableConstFunctions: false,
     bool errorOnUnevaluatedConstant: false}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   final ConstantsTransformer constantsTransformer = new ConstantsTransformer(
       backend,
@@ -176,12 +187,12 @@
   strong,
 }
 
-class ConstantWeakener extends ComputeOnceConstantVisitor<Constant> {
+class ConstantWeakener extends ComputeOnceConstantVisitor<Constant?> {
   ConstantEvaluator _evaluator;
 
   ConstantWeakener(this._evaluator);
 
-  Constant processValue(Constant node, Constant value) {
+  Constant? processValue(Constant node, Constant? value) {
     if (value != null) {
       value = _evaluator.canonicalize(value);
     }
@@ -189,40 +200,40 @@
   }
 
   @override
-  Constant defaultConstant(Constant node) => throw new UnsupportedError(
+  Constant? defaultConstant(Constant node) => throw new UnsupportedError(
       "Unhandled constant ${node} (${node.runtimeType})");
 
   @override
-  Constant visitNullConstant(NullConstant node) => null;
+  Constant? visitNullConstant(NullConstant node) => null;
 
   @override
-  Constant visitBoolConstant(BoolConstant node) => null;
+  Constant? visitBoolConstant(BoolConstant node) => null;
 
   @override
-  Constant visitIntConstant(IntConstant node) => null;
+  Constant? visitIntConstant(IntConstant node) => null;
 
   @override
-  Constant visitDoubleConstant(DoubleConstant node) => null;
+  Constant? visitDoubleConstant(DoubleConstant node) => null;
 
   @override
-  Constant visitStringConstant(StringConstant node) => null;
+  Constant? visitStringConstant(StringConstant node) => null;
 
   @override
-  Constant visitSymbolConstant(SymbolConstant node) => null;
+  Constant? visitSymbolConstant(SymbolConstant node) => null;
 
   @override
-  Constant visitMapConstant(MapConstant node) {
-    DartType keyType = computeConstCanonicalType(
+  Constant? visitMapConstant(MapConstant node) {
+    DartType? keyType = computeConstCanonicalType(
         node.keyType, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    DartType valueType = computeConstCanonicalType(
+    DartType? valueType = computeConstCanonicalType(
         node.valueType, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<ConstantMapEntry> entries;
+    List<ConstantMapEntry>? entries;
     for (int index = 0; index < node.entries.length; index++) {
       ConstantMapEntry entry = node.entries[index];
-      Constant key = visitConstant(entry.key);
-      Constant value = visitConstant(entry.value);
+      Constant? key = visitConstant(entry.key);
+      Constant? value = visitConstant(entry.value);
       if (key != null || value != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] =
@@ -237,13 +248,13 @@
   }
 
   @override
-  Constant visitListConstant(ListConstant node) {
-    DartType typeArgument = computeConstCanonicalType(
+  Constant? visitListConstant(ListConstant node) {
+    DartType? typeArgument = computeConstCanonicalType(
         node.typeArgument, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<Constant> entries;
+    List<Constant>? entries;
     for (int index = 0; index < node.entries.length; index++) {
-      Constant entry = visitConstant(node.entries[index]);
+      Constant? entry = visitConstant(node.entries[index]);
       if (entry != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] = entry;
@@ -257,13 +268,13 @@
   }
 
   @override
-  Constant visitSetConstant(SetConstant node) {
-    DartType typeArgument = computeConstCanonicalType(
+  Constant? visitSetConstant(SetConstant node) {
+    DartType? typeArgument = computeConstCanonicalType(
         node.typeArgument, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<Constant> entries;
+    List<Constant>? entries;
     for (int index = 0; index < node.entries.length; index++) {
-      Constant entry = visitConstant(node.entries[index]);
+      Constant? entry = visitConstant(node.entries[index]);
       if (entry != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] = entry;
@@ -277,10 +288,10 @@
   }
 
   @override
-  Constant visitInstanceConstant(InstanceConstant node) {
-    List<DartType> typeArguments;
+  Constant? visitInstanceConstant(InstanceConstant node) {
+    List<DartType>? typeArguments;
     for (int index = 0; index < node.typeArguments.length; index++) {
-      DartType typeArgument = computeConstCanonicalType(
+      DartType? typeArgument = computeConstCanonicalType(
           node.typeArguments[index], _evaluator.coreTypes,
           isNonNullableByDefault: _evaluator.isNonNullableByDefault);
       if (typeArgument != null) {
@@ -288,9 +299,10 @@
         typeArguments[index] = typeArgument;
       }
     }
-    Map<Reference, Constant> fieldValues;
-    for (Reference reference in node.fieldValues.keys) {
-      Constant value = visitConstant(node.fieldValues[reference]);
+    Map<Reference, Constant>? fieldValues;
+    for (MapEntry<Reference, Constant> entry in node.fieldValues.entries) {
+      Reference reference = entry.key;
+      Constant? value = visitConstant(entry.value);
       if (value != null) {
         fieldValues ??= new Map<Reference, Constant>.from(node.fieldValues);
         fieldValues[reference] = value;
@@ -304,11 +316,11 @@
   }
 
   @override
-  Constant visitPartialInstantiationConstant(
+  Constant? visitPartialInstantiationConstant(
       PartialInstantiationConstant node) {
-    List<DartType> types;
+    List<DartType>? types;
     for (int index = 0; index < node.types.length; index++) {
-      DartType type = computeConstCanonicalType(
+      DartType? type = computeConstCanonicalType(
           node.types[index], _evaluator.coreTypes,
           isNonNullableByDefault: _evaluator.isNonNullableByDefault);
       if (type != null) {
@@ -323,11 +335,11 @@
   }
 
   @override
-  Constant visitTearOffConstant(TearOffConstant node) => null;
+  Constant? visitTearOffConstant(TearOffConstant node) => null;
 
   @override
-  Constant visitTypeLiteralConstant(TypeLiteralConstant node) {
-    DartType type = computeConstCanonicalType(node.type, _evaluator.coreTypes,
+  Constant? visitTypeLiteralConstant(TypeLiteralConstant node) {
+    DartType? type = computeConstCanonicalType(node.type, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
     if (type != null) {
       return new TypeLiteralConstant(type);
@@ -336,14 +348,14 @@
   }
 
   @override
-  Constant visitUnevaluatedConstant(UnevaluatedConstant node) => null;
+  Constant? visitUnevaluatedConstant(UnevaluatedConstant node) => null;
 }
 
 class ConstantsTransformer extends RemovingTransformer {
   final ConstantsBackend backend;
   final ConstantEvaluator constantEvaluator;
   final TypeEnvironment typeEnvironment;
-  StaticTypeContext _staticTypeContext;
+  StaticTypeContext? _staticTypeContext;
 
   final bool evaluateAnnotations;
   final bool enableTripleShift;
@@ -401,7 +413,7 @@
   }
 
   @override
-  LibraryPart visitLibraryPart(LibraryPart node, TreeNode removalSentinel) {
+  LibraryPart visitLibraryPart(LibraryPart node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
     });
@@ -410,7 +422,7 @@
 
   @override
   LibraryDependency visitLibraryDependency(
-      LibraryDependency node, TreeNode removalSentinel) {
+      LibraryDependency node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
     });
@@ -418,8 +430,8 @@
   }
 
   @override
-  Class visitClass(Class node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Class visitClass(Class node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext.forAnnotations(
         node.enclosingLibrary, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
@@ -436,8 +448,8 @@
   }
 
   @override
-  Extension visitExtension(Extension node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Extension visitExtension(Extension node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext.forAnnotations(
         node.enclosingLibrary, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
@@ -449,8 +461,8 @@
   }
 
   @override
-  Procedure visitProcedure(Procedure node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Procedure visitProcedure(Procedure node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -461,8 +473,8 @@
   }
 
   @override
-  Constructor visitConstructor(Constructor node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Constructor visitConstructor(Constructor node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -474,7 +486,7 @@
   }
 
   @override
-  Typedef visitTypedef(Typedef node, TreeNode removalSentinel) {
+  Typedef visitTypedef(Typedef node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
       transformTypeParameterList(node.typeParameters, node);
@@ -487,10 +499,10 @@
 
   @override
   RedirectingFactoryConstructor visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, TreeNode removalSentinel) {
+      RedirectingFactoryConstructor node, TreeNode? removalSentinel) {
     // Currently unreachable as the compiler doesn't produce
     // RedirectingFactoryConstructor.
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -504,7 +516,7 @@
 
   @override
   TypeParameter visitTypeParameter(
-      TypeParameter node, TreeNode removalSentinel) {
+      TypeParameter node, TreeNode? removalSentinel) {
     transformAnnotations(node.annotations, node);
     return node;
   }
@@ -527,36 +539,39 @@
   // Handle definition of constants:
 
   @override
-  FunctionNode visitFunctionNode(FunctionNode node, TreeNode removalSentinel) {
+  FunctionNode visitFunctionNode(FunctionNode node, TreeNode? removalSentinel) {
     transformTypeParameterList(node.typeParameters, node);
     final int positionalParameterCount = node.positionalParameters.length;
     for (int i = 0; i < positionalParameterCount; ++i) {
       final VariableDeclaration variable = node.positionalParameters[i];
       transformAnnotations(variable.annotations, variable);
-      if (variable.initializer != null) {
+      Expression? initializer = variable.initializer;
+      if (initializer != null) {
         variable.initializer =
-            evaluateAndTransformWithContext(variable, variable.initializer)
+            evaluateAndTransformWithContext(variable, initializer)
               ..parent = variable;
       }
     }
     for (final VariableDeclaration variable in node.namedParameters) {
       transformAnnotations(variable.annotations, variable);
-      if (variable.initializer != null) {
+      Expression? initializer = variable.initializer;
+      if (initializer != null) {
         variable.initializer =
-            evaluateAndTransformWithContext(variable, variable.initializer)
+            evaluateAndTransformWithContext(variable, initializer)
               ..parent = variable;
       }
     }
     if (node.body != null) {
-      node.body = transform(node.body)..parent = node;
+      node.body = transform(node.body!)..parent = node;
     }
     return node;
   }
 
   @override
-  Statement visitFunctionDeclaration(
-      FunctionDeclaration node, TreeNode removalSentinel) {
+  TreeNode visitFunctionDeclaration(
+      FunctionDeclaration node, TreeNode? removalSentinel) {
     if (enableConstFunctions) {
+      // ignore: unnecessary_null_comparison
       if (node.function != null) {
         node.function = transform(node.function)..parent = node;
       }
@@ -569,19 +584,20 @@
   }
 
   @override
-  Statement visitVariableDeclaration(
-      VariableDeclaration node, TreeNode removalSentinel) {
+  TreeNode visitVariableDeclaration(
+      VariableDeclaration node, TreeNode? removalSentinel) {
     transformAnnotations(node.annotations, node);
 
-    if (node.initializer != null) {
+    Expression? initializer = node.initializer;
+    if (initializer != null) {
       if (node.isConst) {
-        final Constant constant = evaluateWithContext(node, node.initializer);
+        final Constant constant = evaluateWithContext(node, initializer);
         constantEvaluator.env.addVariableValue(node, constant);
-        node.initializer = makeConstantExpression(constant, node.initializer)
-          ..parent = node;
+        initializer = node.initializer =
+            makeConstantExpression(constant, initializer)..parent = node;
 
         // If this constant is inlined, remove it.
-        if (!keepLocals && shouldInline(node.initializer)) {
+        if (!keepLocals && shouldInline(initializer)) {
           if (constant is! UnevaluatedConstant) {
             // If the constant is unevaluated we need to keep the expression,
             // so that, in the case the constant contains error but the local
@@ -590,45 +606,45 @@
           }
         }
       } else {
-        node.initializer = transform(node.initializer)..parent = node;
+        node.initializer = transform(initializer)..parent = node;
       }
     }
     return node;
   }
 
   @override
-  Field visitField(Field node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  TreeNode visitField(Field node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
-    Field field = constantEvaluator.withNewEnvironment(() {
+    TreeNode result = constantEvaluator.withNewEnvironment(() {
+      Expression? initializer = node.initializer;
       if (node.isConst) {
         transformAnnotations(node.annotations, node);
-        node.initializer =
-            evaluateAndTransformWithContext(node, node.initializer)
-              ..parent = node;
+        initializer = node.initializer =
+            evaluateAndTransformWithContext(node, initializer!)..parent = node;
 
         // If this constant is inlined, remove it.
-        if (!keepFields && shouldInline(node.initializer)) {
-          return removalSentinel;
+        if (!keepFields && shouldInline(initializer)) {
+          return removalSentinel!;
         }
       } else {
         transformAnnotations(node.annotations, node);
-        if (node.initializer != null) {
-          node.initializer = transform(node.initializer)..parent = node;
+        if (initializer != null) {
+          node.initializer = transform(initializer)..parent = node;
         }
       }
       return node;
     });
     _staticTypeContext = oldStaticTypeContext;
-    return field;
+    return result;
   }
 
   // Handle use-sites of constants (and "inline" constant expressions):
 
   @override
-  Expression visitSymbolLiteral(SymbolLiteral node, TreeNode removalSentinel) {
+  TreeNode visitSymbolLiteral(SymbolLiteral node, TreeNode? removalSentinel) {
     return makeConstantExpression(
-        constantEvaluator.evaluate(_staticTypeContext, node), node);
+        constantEvaluator.evaluate(_staticTypeContext!, node), node);
   }
 
   bool _isNull(Expression node) {
@@ -637,7 +653,7 @@
   }
 
   @override
-  Expression visitEqualsCall(EqualsCall node, TreeNode removalSentinel) {
+  TreeNode visitEqualsCall(EqualsCall node, TreeNode? removalSentinel) {
     Expression left = transform(node.left);
     Expression right = transform(node.right);
     if (_isNull(left)) {
@@ -651,17 +667,17 @@
   }
 
   @override
-  Expression visitStaticGet(StaticGet node, TreeNode removalSentinel) {
+  TreeNode visitStaticGet(StaticGet node, TreeNode? removalSentinel) {
     final Member target = node.target;
     if (target is Field && target.isConst) {
       // Make sure the initializer is evaluated first.
-      StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+      StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
       _staticTypeContext = new StaticTypeContext(target, typeEnvironment);
       target.initializer =
-          evaluateAndTransformWithContext(target, target.initializer)
+          evaluateAndTransformWithContext(target, target.initializer!)
             ..parent = target;
       _staticTypeContext = oldStaticTypeContext;
-      if (shouldInline(target.initializer)) {
+      if (shouldInline(target.initializer!)) {
         return evaluateAndTransformWithContext(node, node);
       }
     } else if (target is Procedure && target.kind == ProcedureKind.Method) {
@@ -671,7 +687,7 @@
   }
 
   @override
-  Expression visitStaticTearOff(StaticTearOff node, TreeNode removalSentinel) {
+  TreeNode visitStaticTearOff(StaticTearOff node, TreeNode? removalSentinel) {
     final Member target = node.target;
     if (target is Procedure && target.kind == ProcedureKind.Method) {
       return evaluateAndTransformWithContext(node, node);
@@ -680,28 +696,28 @@
   }
 
   @override
-  SwitchCase visitSwitchCase(SwitchCase node, TreeNode removalSentinel) {
+  TreeNode visitSwitchCase(SwitchCase node, TreeNode? removalSentinel) {
     transformExpressions(node.expressions, node);
     return super.visitSwitchCase(node, removalSentinel);
   }
 
   @override
-  SwitchStatement visitSwitchStatement(
-      SwitchStatement node, TreeNode removalSentinel) {
-    SwitchStatement result = super.visitSwitchStatement(node, removalSentinel);
+  TreeNode visitSwitchStatement(
+      SwitchStatement node, TreeNode? removalSentinel) {
+    TreeNode result = super.visitSwitchStatement(node, removalSentinel);
     Library library = constantEvaluator.libraryOf(node);
+    // ignore: unnecessary_null_comparison
     if (library != null && library.isNonNullableByDefault) {
       for (SwitchCase switchCase in node.cases) {
         for (Expression caseExpression in switchCase.expressions) {
           if (caseExpression is ConstantExpression) {
             if (!constantEvaluator.hasPrimitiveEqual(caseExpression.constant)) {
-              Uri uri = constantEvaluator.getFileUri(caseExpression);
-              int offset = constantEvaluator.getFileOffset(uri, caseExpression);
               constantEvaluator.errorReporter.report(
-                  templateConstEvalCaseImplementsEqual
-                      .withArguments(caseExpression.constant,
-                          constantEvaluator.isNonNullableByDefault)
-                      .withLocation(uri, offset, noLength),
+                  constantEvaluator.createLocatedMessage(
+                      caseExpression,
+                      templateConstEvalCaseImplementsEqual.withArguments(
+                          caseExpression.constant,
+                          constantEvaluator.isNonNullableByDefault)),
                   null);
             }
           } else {
@@ -715,13 +731,13 @@
   }
 
   @override
-  Expression visitVariableGet(VariableGet node, TreeNode removalSentinel) {
+  TreeNode visitVariableGet(VariableGet node, TreeNode? removalSentinel) {
     final VariableDeclaration variable = node.variable;
     if (variable.isConst) {
       variable.initializer =
-          evaluateAndTransformWithContext(variable, variable.initializer)
+          evaluateAndTransformWithContext(variable, variable.initializer!)
             ..parent = variable;
-      if (shouldInline(variable.initializer)) {
+      if (shouldInline(variable.initializer!)) {
         return evaluateAndTransformWithContext(node, node);
       }
     }
@@ -729,7 +745,7 @@
   }
 
   @override
-  Expression visitListLiteral(ListLiteral node, TreeNode removalSentinel) {
+  TreeNode visitListLiteral(ListLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -737,13 +753,13 @@
   }
 
   @override
-  Expression visitListConcatenation(
-      ListConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitListConcatenation(
+      ListConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitSetLiteral(SetLiteral node, TreeNode removalSentinel) {
+  TreeNode visitSetLiteral(SetLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -751,13 +767,13 @@
   }
 
   @override
-  Expression visitSetConcatenation(
-      SetConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitSetConcatenation(
+      SetConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitMapLiteral(MapLiteral node, TreeNode removalSentinel) {
+  TreeNode visitMapLiteral(MapLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -765,7 +781,7 @@
   }
 
   @override
-  Expression visitTypeLiteral(TypeLiteral node, TreeNode removalSentinel) {
+  TreeNode visitTypeLiteral(TypeLiteral node, TreeNode? removalSentinel) {
     if (!containsFreeTypeVariables(node.type)) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -773,14 +789,14 @@
   }
 
   @override
-  Expression visitMapConcatenation(
-      MapConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitMapConcatenation(
+      MapConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitConstructorInvocation(
-      ConstructorInvocation node, TreeNode removalSentinel) {
+  TreeNode visitConstructorInvocation(
+      ConstructorInvocation node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -788,8 +804,8 @@
   }
 
   @override
-  Expression visitStaticInvocation(
-      StaticInvocation node, TreeNode removalSentinel) {
+  TreeNode visitStaticInvocation(
+      StaticInvocation node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -797,8 +813,8 @@
   }
 
   @override
-  Expression visitConstantExpression(
-      ConstantExpression node, TreeNode removalSentinel) {
+  TreeNode visitConstantExpression(
+      ConstantExpression node, TreeNode? removalSentinel) {
     Constant constant = node.constant;
     if (constant is UnevaluatedConstant) {
       Expression expression = constant.expression;
@@ -816,10 +832,10 @@
 
   Constant evaluateWithContext(TreeNode treeContext, Expression node) {
     if (treeContext == node) {
-      return constantEvaluator.evaluate(_staticTypeContext, node);
+      return constantEvaluator.evaluate(_staticTypeContext!, node);
     }
 
-    return constantEvaluator.evaluate(_staticTypeContext, node,
+    return constantEvaluator.evaluate(_staticTypeContext!, node,
         contextNode: treeContext);
   }
 
@@ -829,7 +845,7 @@
       return constant.expression;
     }
     return new ConstantExpression(
-        constant, node.getStaticType(_staticTypeContext))
+        constant, node.getStaticType(_staticTypeContext!))
       ..fileOffset = node.fileOffset;
   }
 
@@ -844,12 +860,12 @@
 class ConstantEvaluator implements ExpressionVisitor<Constant> {
   final ConstantsBackend backend;
   final NumberSemantics numberSemantics;
-  ConstantIntFolder intFolder;
-  Map<String, String> environmentDefines;
+  late ConstantIntFolder intFolder;
+  Map<String, String>? environmentDefines;
   final bool errorOnUnevaluatedConstant;
   final CoreTypes coreTypes;
   final TypeEnvironment typeEnvironment;
-  StaticTypeContext _staticTypeContext;
+  StaticTypeContext? _staticTypeContext;
   final ErrorReporter errorReporter;
   final EvaluationMode evaluationMode;
 
@@ -860,31 +876,31 @@
       new IsInstantiatedVisitor().isInstantiated;
 
   final Map<Constant, Constant> canonicalizationCache;
-  final Map<Node, Object> nodeCache;
+  final Map<Node, Constant?> nodeCache;
   final CloneVisitorNotMembers cloner = new CloneVisitorNotMembers();
 
-  Map<Class, bool> primitiveEqualCache;
+  late Map<Class, bool> primitiveEqualCache;
 
   final NullConstant nullConstant = new NullConstant();
   final BoolConstant trueConstant = new BoolConstant(true);
   final BoolConstant falseConstant = new BoolConstant(false);
 
-  InstanceBuilder instanceBuilder;
+  InstanceBuilder? instanceBuilder;
   EvaluationEnvironment env;
   Set<Expression> replacementNodes = new Set<Expression>.identity();
   Map<Constant, Constant> lowered = new Map<Constant, Constant>.identity();
 
-  bool seenUnevaluatedChild; // Any children that were left unevaluated?
-  int lazyDepth; // Current nesting depth of lazy regions.
+  bool seenUnevaluatedChild = false; // Any children that were left unevaluated?
+  int lazyDepth = -1; // Current nesting depth of lazy regions.
 
   bool get shouldBeUnevaluated => seenUnevaluatedChild || lazyDepth != 0;
 
   bool get targetingJavaScript => numberSemantics == NumberSemantics.js;
 
   bool get isNonNullableByDefault =>
-      _staticTypeContext.nonNullable == Nullability.nonNullable;
+      _staticTypeContext!.nonNullable == Nullability.nonNullable;
 
-  ConstantWeakener _weakener;
+  late ConstantWeakener _weakener;
 
   ConstantEvaluator(this.backend, this.environmentDefines, this.typeEnvironment,
       this.errorReporter,
@@ -925,11 +941,11 @@
       case EvaluationMode.agnostic:
         return norm(coreTypes, type);
       case EvaluationMode.weak:
-        return computeConstCanonicalType(norm(coreTypes, type), coreTypes,
-            isNonNullableByDefault: isNonNullableByDefault);
+        type = norm(coreTypes, type);
+        return computeConstCanonicalType(type, coreTypes,
+                isNonNullableByDefault: isNonNullableByDefault) ??
+            type;
     }
-    throw new UnsupportedError(
-        "Unexpected evaluation mode: ${evaluationMode}.");
   }
 
   List<DartType> convertTypes(List<DartType> types) {
@@ -938,24 +954,37 @@
       case EvaluationMode.agnostic:
         return types.map((DartType type) => norm(coreTypes, type)).toList();
       case EvaluationMode.weak:
-        return types
-            .map((DartType type) => computeConstCanonicalType(
-                norm(coreTypes, type), coreTypes,
-                isNonNullableByDefault: isNonNullableByDefault))
-            .toList();
+        return types.map((DartType type) {
+          type = norm(coreTypes, type);
+          return computeConstCanonicalType(type, coreTypes,
+                  isNonNullableByDefault: isNonNullableByDefault) ??
+              type;
+        }).toList();
     }
-    throw new UnsupportedError(
-        "Unexpected evaluation mode: ${evaluationMode}.");
   }
 
-  Uri getFileUri(TreeNode node) {
-    while (node != null && node is! FileUriNode) {
+  LocatedMessage createLocatedMessage(TreeNode? node, Message message) {
+    Uri? uri = getFileUri(node);
+    if (uri == null) {
+      // TODO(johnniwinther): Ensure that we always have a uri.
+      return message.withoutLocation();
+    }
+    int offset = getFileOffset(uri, node);
+    return message.withLocation(uri, offset, noLength);
+  }
+
+  // TODO(johnniwinther): Avoid this by adding a current file uri field.
+  Uri? getFileUri(TreeNode? node) {
+    while (node != null) {
+      if (node is FileUriNode) {
+        return node.fileUri;
+      }
       node = node.parent;
     }
-    return (node as FileUriNode)?.fileUri;
+    return null;
   }
 
-  int getFileOffset(Uri uri, TreeNode node) {
+  int getFileOffset(Uri? uri, TreeNode? node) {
     if (uri == null) return TreeNode.noOffset;
     while (node != null && node.fileOffset == TreeNode.noOffset) {
       node = node.parent;
@@ -968,34 +997,27 @@
   /// If the expression in the UnevaluatedConstant is an InvalidExpression,
   /// an error occurred during constant evaluation.
   Constant evaluate(StaticTypeContext context, Expression node,
-      {TreeNode contextNode}) {
+      {TreeNode? contextNode}) {
     _staticTypeContext = context;
     seenUnevaluatedChild = false;
     lazyDepth = 0;
     Constant result = _evaluateSubexpression(node);
     if (result is AbortConstant) {
       if (result is _AbortDueToErrorConstant) {
-        final Uri uri = getFileUri(result.node);
-        final int fileOffset = getFileOffset(uri, result.node);
         final LocatedMessage locatedMessageActualError =
-            result.message.withLocation(uri, fileOffset, noLength);
-
+            createLocatedMessage(result.node, result.message);
         final List<LocatedMessage> contextMessages = <LocatedMessage>[
           locatedMessageActualError
         ];
-        if (result.context != null) contextMessages.addAll(result.context);
+        if (result.context != null) contextMessages.addAll(result.context!);
         if (contextNode != null && contextNode != result.node) {
-          final Uri uri = getFileUri(contextNode);
-          final int fileOffset = getFileOffset(uri, contextNode);
-          contextMessages.add(
-              messageConstEvalContext.withLocation(uri, fileOffset, noLength));
+          contextMessages
+              .add(createLocatedMessage(contextNode, messageConstEvalContext));
         }
 
         {
-          final Uri uri = getFileUri(node);
-          final int fileOffset = getFileOffset(uri, node);
-          final LocatedMessage locatedMessage = messageConstEvalStartingPoint
-              .withLocation(uri, fileOffset, noLength);
+          final LocatedMessage locatedMessage =
+              createLocatedMessage(node, messageConstEvalStartingPoint);
           errorReporter.report(locatedMessage, contextMessages);
         }
         return new UnevaluatedConstant(
@@ -1008,7 +1030,7 @@
         return new UnevaluatedConstant(invalid);
       } else if (result is _AbortDueToThrowConstant) {
         final Object value = result.throwValue;
-        Message message;
+        Message? message;
         if (value is Constant) {
           message = templateConstEvalUnhandledException.withArguments(
               value, isNonNullableByDefault);
@@ -1018,18 +1040,14 @@
         }
         assert(message != null);
 
-        final Uri uri = getFileUri(result.node);
-        final int fileOffset = getFileOffset(uri, result.node);
         final LocatedMessage locatedMessageActualError =
-            message.withLocation(uri, fileOffset, noLength);
+            createLocatedMessage(result.node, message!);
         final List<LocatedMessage> contextMessages = <LocatedMessage>[
           locatedMessageActualError
         ];
         {
-          final Uri uri = getFileUri(node);
-          final int fileOffset = getFileOffset(uri, node);
-          final LocatedMessage locatedMessage = messageConstEvalStartingPoint
-              .withLocation(uri, fileOffset, noLength);
+          final LocatedMessage locatedMessage =
+              createLocatedMessage(node, messageConstEvalStartingPoint);
           errorReporter.report(locatedMessage, contextMessages);
         }
         return new UnevaluatedConstant(new InvalidExpression(message.message));
@@ -1052,11 +1070,12 @@
         new StatementConstantEvaluator(this);
     ExecutionStatus status = statement.accept(statementEvaluator);
     if (status is ReturnStatus) {
-      if (status.value == null) {
+      Constant? value = status.value;
+      if (value == null) {
         // Void return type from executing the function body.
         return new NullConstant();
       }
-      return status.value;
+      return value;
     } else if (status is AbortStatus) {
       return status.error;
     } else if (status is ProceedStatus) {
@@ -1069,8 +1088,8 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant executeConstructorBody(Constructor constructor) {
-    final Statement body = constructor.function.body;
+  AbortConstant? executeConstructorBody(Constructor constructor) {
+    final Statement body = constructor.function.body!;
     StatementConstantEvaluator statementEvaluator =
         new StatementConstantEvaluator(this);
     ExecutionStatus status = body.accept(statementEvaluator);
@@ -1091,7 +1110,7 @@
   /// Create an error-constant indicating that an error has been detected during
   /// constant evaluation.
   AbortConstant createErrorConstant(TreeNode node, Message message,
-      {List<LocatedMessage> context}) {
+      {List<LocatedMessage>? context}) {
     return new _AbortDueToErrorConstant(node, message, context: context);
   }
 
@@ -1106,7 +1125,7 @@
   Constant unevaluated(Expression original, Expression replacement) {
     replacement.fileOffset = original.fileOffset;
     return new UnevaluatedConstant(
-        new FileUriExpression(replacement, getFileUri(original))
+        new FileUriExpression(replacement, getFileUri(original)!)
           ..fileOffset = original.fileOffset);
   }
 
@@ -1175,7 +1194,7 @@
   }
 
   void _recordConstructorCoverage(Constructor constructor, TreeNode caller) {
-    Uri currentUri = getFileUri(caller);
+    Uri currentUri = getFileUri(caller)!;
     Set<Reference> uriCoverage = _constructorCoverage[currentUri] ??= {};
     uriCoverage.add(constructor.reference);
   }
@@ -1211,21 +1230,23 @@
       // value.
       bool isGetter = node is InstanceGet || node is PropertyGet;
       if (nodeCache.containsKey(node) && !(enableConstFunctions && isGetter)) {
-        result = nodeCache[node];
-        if (result == null) {
+        Constant? cachedResult = nodeCache[node];
+        if (cachedResult == null) {
           // [null] is a sentinel value only used when still evaluating the same
           // node.
           return createErrorConstant(node, messageConstEvalCircularity);
         }
+        result = cachedResult;
       } else {
         nodeCache[node] = null;
-        result = node.accept(this);
-        if (result is AbortConstant) {
+        Constant evaluatedResult = node.accept(this);
+        if (evaluatedResult is AbortConstant) {
           nodeCache.remove(node);
-          return result;
+          return evaluatedResult;
         } else {
-          nodeCache[node] = result;
+          nodeCache[node] = evaluatedResult;
         }
+        result = evaluatedResult;
       }
     } else {
       bool sentinelInserted = false;
@@ -1247,19 +1268,20 @@
         nodeCache[node] = null;
         sentinelInserted = true;
       }
-      result = node.accept(this);
+      Constant evaluatedResult = node.accept(this);
       if (sentinelInserted) {
         nodeCache.remove(node);
       }
-      if (result is AbortConstant) {
-        return result;
+      if (evaluatedResult is AbortConstant) {
+        return evaluatedResult;
       }
+      result = evaluatedResult;
     }
     seenUnevaluatedChild = wasUnevaluated || result is UnevaluatedConstant;
     return result;
   }
 
-  Constant _evaluateNullableSubexpression(Expression node) {
+  Constant _evaluateNullableSubexpression(Expression? node) {
     if (node == null) return nullConstant;
     return _evaluateSubexpression(node);
   }
@@ -1304,16 +1326,17 @@
 
   @override
   Constant visitTypeLiteral(TypeLiteral node) {
-    DartType type = _evaluateDartType(node, node.type);
+    DartType? type = _evaluateDartType(node, node.type);
     if (type != null) {
       type = convertType(type);
     }
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
     return canonicalize(new TypeLiteralConstant(type));
   }
@@ -1353,7 +1376,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (Expression element in node.expressions) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1366,7 +1389,7 @@
     final ListConstantBuilder builder =
         new ListConstantBuilder(node, convertType(node.typeArgument), this);
     for (Expression list in node.lists) {
-      AbortConstant error = builder.addSpread(list);
+      AbortConstant? error = builder.addSpread(list);
       if (error != null) return error;
     }
     return builder.build();
@@ -1386,7 +1409,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (Expression element in node.expressions) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1399,7 +1422,7 @@
     final SetConstantBuilder builder =
         new SetConstantBuilder(node, convertType(node.typeArgument), this);
     for (Expression set_ in node.sets) {
-      AbortConstant error = builder.addSpread(set_);
+      AbortConstant? error = builder.addSpread(set_);
       if (error != null) return error;
     }
     return builder.build();
@@ -1419,7 +1442,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (MapLiteralEntry element in node.entries) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1432,7 +1455,7 @@
     final MapConstantBuilder builder = new MapConstantBuilder(
         node, convertType(node.keyType), convertType(node.valueType), this);
     for (Expression map in node.maps) {
-      AbortConstant error = builder.addSpread(map);
+      AbortConstant? error = builder.addSpread(map);
       if (error != null) return error;
     }
     return builder.build();
@@ -1454,7 +1477,7 @@
     }
 
     final Constructor constructor = node.target;
-    AbortConstant error = checkConstructorConst(node, constructor);
+    AbortConstant? error = checkConstructorConst(node, constructor);
     if (error != null) return error;
 
     final Class klass = constructor.enclosingClass;
@@ -1464,23 +1487,26 @@
           node, 'Constructor "$node" belongs to abstract class "${klass}".');
     }
 
-    final List<Constant> positionals =
+    final List<Constant>? positionals =
         _evaluatePositionalArguments(node.arguments);
-    if (positionals == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (positionals == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(positionals != null);
 
-    final Map<String, Constant> named = _evaluateNamedArguments(node.arguments);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named =
+        _evaluateNamedArguments(node.arguments);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     bool isSymbol = klass == coreTypes.internalSymbolClass;
@@ -1506,13 +1532,14 @@
               nameValue, isNonNullableByDefault));
     }
 
-    List<DartType> types = _evaluateTypeArguments(node, node.arguments);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, node.arguments);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     final List<DartType> typeArguments = convertTypes(types);
@@ -1529,25 +1556,25 @@
       // initialize the fields of the new instance.
       if (shouldBeUnevaluated) {
         enterLazy();
-        AbortConstant error = handleConstructorInvocation(
+        AbortConstant? error = handleConstructorInvocation(
             constructor, typeArguments, positionals, named, node);
         if (error != null) return error;
         leaveLazy();
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
-      AbortConstant error = handleConstructorInvocation(
+      AbortConstant? error = handleConstructorInvocation(
           constructor, typeArguments, positionals, named, node);
       if (error != null) return error;
       if (shouldBeUnevaluated) {
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
-      return canonicalize(instanceBuilder.buildInstance());
+      return canonicalize(instanceBuilder!.buildInstance());
     });
   }
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant checkConstructorConst(TreeNode node, Constructor constructor) {
+  AbortConstant? checkConstructorConst(TreeNode node, Constructor constructor) {
     if (!constructor.isConst) {
       return createInvalidExpressionConstant(
           node, 'Non-const constructor invocation.');
@@ -1569,19 +1596,20 @@
     return withNewInstanceBuilder(
         node.classNode, convertTypes(node.typeArguments), () {
       for (AssertStatement statement in node.asserts) {
-        AbortConstant error = checkAssert(statement);
+        AbortConstant? error = checkAssert(statement);
         if (error != null) return error;
       }
-      AbortConstant error;
-      node.fieldValues.forEach((Reference fieldRef, Expression value) {
-        if (error != null) return;
+      AbortConstant? error;
+      for (MapEntry<Reference, Expression> entry in node.fieldValues.entries) {
+        Reference fieldRef = entry.key;
+        Expression value = entry.value;
         Constant constant = _evaluateSubexpression(value);
         if (constant is AbortConstant) {
-          error ??= constant;
-          return;
+          error = constant;
+          break;
         }
-        instanceBuilder.setFieldValue(fieldRef.asField, constant);
-      });
+        instanceBuilder!.setFieldValue(fieldRef.asField, constant);
+      }
       if (error != null) return error;
       for (Expression value in node.unusedArguments) {
         if (error != null) return error;
@@ -1591,15 +1619,15 @@
           return error;
         }
         if (constant is UnevaluatedConstant) {
-          instanceBuilder.unusedArguments.add(extract(constant));
+          instanceBuilder!.unusedArguments.add(extract(constant));
         }
       }
       if (error != null) return error;
       if (shouldBeUnevaluated) {
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
       // We can get here when re-evaluating a previously unevaluated constant.
-      return canonicalize(instanceBuilder.buildInstance());
+      return canonicalize(instanceBuilder!.buildInstance());
     });
   }
 
@@ -1643,6 +1671,7 @@
       'unary-'
     };
 
+    // ignore: unnecessary_null_comparison
     if (name == null) return false;
     if (name == '') return true;
 
@@ -1730,7 +1759,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant handleConstructorInvocation(
+  AbortConstant? handleConstructorInvocation(
       Constructor constructor,
       List<DartType> typeArguments,
       List<Constant> positionalArguments,
@@ -1773,49 +1802,52 @@
         if (!field.isStatic) {
           Constant constant = _evaluateNullableSubexpression(field.initializer);
           if (constant is AbortConstant) return constant;
-          instanceBuilder.setFieldValue(field, constant);
+          instanceBuilder!.setFieldValue(field, constant);
         }
       }
       for (final Initializer init in constructor.initializers) {
         if (init is FieldInitializer) {
           Constant constant = _evaluateSubexpression(init.value);
           if (constant is AbortConstant) return constant;
-          instanceBuilder.setFieldValue(init.field, constant);
+          instanceBuilder!.setFieldValue(init.field, constant);
         } else if (init is LocalInitializer) {
           final VariableDeclaration variable = init.variable;
-          Constant constant = _evaluateSubexpression(variable.initializer);
+          Constant constant = _evaluateSubexpression(variable.initializer!);
           if (constant is AbortConstant) return constant;
           env.addVariableValue(variable, constant);
         } else if (init is SuperInitializer) {
-          AbortConstant error = checkConstructorConst(init, constructor);
+          AbortConstant? error = checkConstructorConst(init, constructor);
           if (error != null) return error;
-          List<DartType> types = _evaluateSuperTypeArguments(
-              init, constructor.enclosingClass.supertype);
-          if (types == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          List<DartType>? types = _evaluateSuperTypeArguments(
+              init, constructor.enclosingClass.supertype!);
+          if (types == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(types != null);
 
-          List<Constant> positionalArguments =
+          List<Constant>? positionalArguments =
               _evaluatePositionalArguments(init.arguments);
-          if (positionalArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (positionalArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(positionalArguments != null);
-          Map<String, Constant> namedArguments =
+          Map<String, Constant>? namedArguments =
               _evaluateNamedArguments(init.arguments);
-          if (namedArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (namedArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(namedArguments != null);
           error = handleConstructorInvocation(init.target, types,
               positionalArguments, namedArguments, constructor);
@@ -1823,33 +1855,35 @@
         } else if (init is RedirectingInitializer) {
           // Since a redirecting constructor targets a constructor of the same
           // class, we pass the same [typeArguments].
-          AbortConstant error = checkConstructorConst(init, constructor);
+          AbortConstant? error = checkConstructorConst(init, constructor);
           if (error != null) return error;
-          List<Constant> positionalArguments =
+          List<Constant>? positionalArguments =
               _evaluatePositionalArguments(init.arguments);
-          if (positionalArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (positionalArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(positionalArguments != null);
 
-          Map<String, Constant> namedArguments =
+          Map<String, Constant>? namedArguments =
               _evaluateNamedArguments(init.arguments);
-          if (namedArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (namedArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(namedArguments != null);
 
           error = handleConstructorInvocation(init.target, typeArguments,
               positionalArguments, namedArguments, constructor);
           if (error != null) return error;
         } else if (init is AssertInitializer) {
-          AbortConstant error = checkAssert(init.statement);
+          AbortConstant? error = checkAssert(init.statement);
           if (error != null) return error;
         } else {
           // InvalidInitializer or new Initializers.
@@ -1866,11 +1900,12 @@
       }
 
       for (UnevaluatedConstant constant in env.unevaluatedUnreadConstants) {
-        instanceBuilder.unusedArguments.add(extract(constant));
+        instanceBuilder!.unusedArguments.add(extract(constant));
       }
 
+      // ignore: unnecessary_null_comparison
       if (enableConstFunctions && constructor.function != null) {
-        AbortConstant error = executeConstructorBody(constructor);
+        AbortConstant? error = executeConstructorBody(constructor);
         if (error != null) return error;
       }
 
@@ -1880,20 +1915,20 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant checkAssert(AssertStatement statement) {
+  AbortConstant? checkAssert(AssertStatement statement) {
     final Constant condition = _evaluateSubexpression(statement.condition);
     if (condition is AbortConstant) return condition;
 
     if (shouldBeUnevaluated) {
-      Expression message = null;
+      Expression? message = null;
       if (statement.message != null) {
         enterLazy();
-        Constant constant = _evaluateSubexpression(statement.message);
+        Constant constant = _evaluateSubexpression(statement.message!);
         if (constant is AbortConstant) return constant;
         message = extract(constant);
         leaveLazy();
       }
-      instanceBuilder.asserts.add(new AssertStatement(extract(condition),
+      instanceBuilder!.asserts.add(new AssertStatement(extract(condition),
           message: message,
           conditionStartOffset: statement.conditionStartOffset,
           conditionEndOffset: statement.conditionEndOffset));
@@ -1903,10 +1938,10 @@
           return createErrorConstant(
               statement.condition, messageConstEvalFailedAssertion);
         }
-        final Constant message = _evaluateSubexpression(statement.message);
+        final Constant message = _evaluateSubexpression(statement.message!);
         if (message is AbortConstant) return message;
         if (shouldBeUnevaluated) {
-          instanceBuilder.asserts.add(new AssertStatement(extract(condition),
+          instanceBuilder!.asserts.add(new AssertStatement(extract(condition),
               message: extract(message),
               conditionStartOffset: statement.conditionStartOffset,
               conditionEndOffset: statement.conditionEndOffset));
@@ -1917,11 +1952,11 @@
                   .withArguments(message.value));
         } else {
           return createErrorConstant(
-              statement.message,
+              statement.message!,
               templateConstEvalInvalidType.withArguments(
                   message,
                   typeEnvironment.coreTypes.stringLegacyRawType,
-                  message.getType(_staticTypeContext),
+                  message.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
       }
@@ -1931,7 +1966,7 @@
           templateConstEvalInvalidType.withArguments(
               condition,
               typeEnvironment.coreTypes.boolLegacyRawType,
-              condition.getType(_staticTypeContext),
+              condition.getType(_staticTypeContext!),
               isNonNullableByDefault));
     }
 
@@ -1940,7 +1975,7 @@
 
   @override
   Constant visitInvalidExpression(InvalidExpression node) {
-    return createInvalidExpressionConstant(node, node.message);
+    return createInvalidExpressionConstant(node, node.message ?? '');
   }
 
   @override
@@ -1959,15 +1994,16 @@
 
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (shouldBeUnevaluated) {
@@ -1997,15 +2033,16 @@
 
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (shouldBeUnevaluated) {
@@ -2040,7 +2077,8 @@
       return createInvalidExpressionConstant(node, "local function invocation");
     }
 
-    final Constant receiver = env.lookupVariable(node.variable);
+    final Constant receiver = env.lookupVariable(node.variable)!;
+    // ignore: unnecessary_null_comparison
     assert(receiver != null);
     if (receiver is AbortConstant) return receiver;
 
@@ -2049,35 +2087,38 @@
 
   Constant _evaluateFunctionInvocation(
       TreeNode node, Constant receiver, Arguments argumentsNode) {
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(argumentsNode);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     // Evaluate type arguments of the function invoked.
-    List<DartType> types = _evaluateTypeArguments(node, argumentsNode);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, argumentsNode);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     // Evaluate named arguments of the function invoked.
-    final Map<String, Constant> named = _evaluateNamedArguments(argumentsNode);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named = _evaluateNamedArguments(argumentsNode);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     if (receiver is FunctionValue) {
@@ -2136,25 +2177,13 @@
       return createErrorConstant(
           node,
           templateConstEvalInvalidEqualsOperandType.withArguments(
-              left, left.getType(_staticTypeContext), isNonNullableByDefault));
+              left, left.getType(_staticTypeContext!), isNonNullableByDefault));
     }
   }
 
-  /// Converts integer constant types to an int value.
-  ///
-  /// Returns [null] on unmatched [intFolder] and [value] type.
-  int _convertToInt(Constant value) {
-    if (intFolder is JsConstantIntFolder && value is DoubleConstant) {
-      return value.value.toInt();
-    } else if (intFolder is VmConstantIntFolder && value is IntConstant) {
-      return value.value;
-    }
-    return null;
-  }
-
   Constant _handleInvocation(
       Expression node, Name name, Constant receiver, List<Constant> arguments,
-      {List<DartType> typeArguments, Map<String, Constant> namedArguments}) {
+      {List<DartType>? typeArguments, Map<String, Constant>? namedArguments}) {
     final String op = name.text;
 
     // TODO(kallentu): Handle all constant toString methods.
@@ -2187,14 +2216,12 @@
                     '+',
                     receiver,
                     typeEnvironment.coreTypes.stringLegacyRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           case '[]':
             if (enableConstFunctions) {
-              if (intFolder.isInt(other)) {
-                int index = _convertToInt(other);
-                assert(index != null);
-
+              int? index = intFolder.asInt(other);
+              if (index != null) {
                 if (index < 0 || index >= receiver.value.length) {
                   return new _AbortDueToThrowConstant(
                       node, new RangeError.index(index, receiver.value));
@@ -2207,7 +2234,7 @@
                       '[]',
                       receiver,
                       typeEnvironment.coreTypes.intNonNullableRawType,
-                      other.getType(_staticTypeContext),
+                      other.getType(_staticTypeContext!),
                       isNonNullableByDefault));
             }
         }
@@ -2229,7 +2256,7 @@
                     op,
                     other,
                     typeEnvironment.coreTypes.intLegacyRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           }
           num receiverValue = (receiver as PrimitiveConstant<num>).value;
@@ -2242,7 +2269,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.numLegacyRawType,
-                other.getType(_staticTypeContext),
+                other.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
     } else if (receiver is DoubleConstant) {
@@ -2254,7 +2281,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.intLegacyRawType,
-                receiver.getType(_staticTypeContext),
+                receiver.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
       if (arguments.length == 0) {
@@ -2276,7 +2303,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.numLegacyRawType,
-                other.getType(_staticTypeContext),
+                other.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
     } else if (receiver is BoolConstant) {
@@ -2303,10 +2330,8 @@
         final Constant other = arguments[0];
         switch (op) {
           case '[]':
-            if (intFolder.isInt(other)) {
-              int index = _convertToInt(other);
-              assert(index != null);
-
+            int? index = intFolder.asInt(other);
+            if (index != null) {
               if (index < 0 || index >= receiver.entries.length) {
                 return new _AbortDueToThrowConstant(
                     node, new RangeError.index(index, receiver.entries));
@@ -2319,7 +2344,7 @@
                     '[]',
                     receiver,
                     typeEnvironment.coreTypes.intNonNullableRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           case 'add':
             if (receiver is MutableListConstant) {
@@ -2334,25 +2359,29 @@
         final Constant other = arguments[0];
         switch (op) {
           case '[]':
-            final ConstantMapEntry mapEntry = receiver.entries
-                .firstWhere((entry) => entry.key == other, orElse: () => null);
-            // Null value if key is not in the map.
-            return mapEntry?.value ?? new NullConstant();
+            for (ConstantMapEntry entry in receiver.entries) {
+              if (entry.key == other) {
+                return entry.value;
+              }
+            }
+            return new NullConstant();
         }
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
       final Class instanceClass = receiver.classNode;
       assert(typeEnvironment.hierarchy is ClassHierarchy);
       final Member member = (typeEnvironment.hierarchy as ClassHierarchy)
-          .getDispatchTarget(instanceClass, name);
-      final FunctionNode function = member.function;
+          .getDispatchTarget(instanceClass, name)!;
+      final FunctionNode? function = member.function;
 
       // TODO(kallentu): Implement [Object] class methods which have backend
       // specific functions that cannot be run by the constant evaluator.
       final bool isObjectMember = member.enclosingClass != null &&
-          member.enclosingClass.name == "Object";
+          member.enclosingClass!.name == "Object";
       if (function != null && !isObjectMember) {
-        return withNewInstanceBuilder(instanceClass, typeArguments, () {
+        // TODO(johnniwinther): Make [typeArguments] and [namedArguments]
+        // required and non-nullable.
+        return withNewInstanceBuilder(instanceClass, typeArguments!, () {
           final EvaluationEnvironment newEnv = new EvaluationEnvironment();
           for (int i = 0; i < instanceClass.typeParameters.length; i++) {
             newEnv.addTypeParameterValue(
@@ -2361,9 +2390,9 @@
 
           // Ensure that fields are visible for instance access.
           receiver.fieldValues.forEach((Reference fieldRef, Constant value) =>
-              instanceBuilder.setFieldValue(fieldRef.asField, value));
+              instanceBuilder!.setFieldValue(fieldRef.asField, value));
           return _handleFunctionInvocation(
-              function, receiver.typeArguments, arguments, namedArguments,
+              function, receiver.typeArguments, arguments, namedArguments!,
               functionEnvironment: newEnv);
         });
       }
@@ -2399,37 +2428,40 @@
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
 
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (enableConstFunctions) {
       // Evaluate type arguments of the method invoked.
-      List<DartType> types = _evaluateTypeArguments(node, node.arguments);
-      if (types == null && _gotError != null) {
-        AbortConstant error = _gotError;
+      List<DartType>? types = _evaluateTypeArguments(node, node.arguments);
+      if (types == null) {
+        AbortConstant error = _gotError!;
         _gotError = null;
         return error;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(types != null);
 
       // Evaluate named arguments of the method invoked.
-      final Map<String, Constant> named =
+      final Map<String, Constant>? named =
           _evaluateNamedArguments(node.arguments);
-      if (named == null && _gotError != null) {
-        AbortConstant error = _gotError;
+      if (named == null) {
+        AbortConstant error = _gotError!;
         _gotError = null;
         return error;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(named != null);
 
       if (receiver is FunctionValue) {
@@ -2488,7 +2520,7 @@
                   logicalExpressionOperatorToString(node.operatorEnum),
                   left,
                   typeEnvironment.coreTypes.boolLegacyRawType,
-                  right.getType(_staticTypeContext),
+                  right.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
         return createErrorConstant(
@@ -2513,7 +2545,7 @@
                   logicalExpressionOperatorToString(node.operatorEnum),
                   left,
                   typeEnvironment.coreTypes.boolLegacyRawType,
-                  right.getType(_staticTypeContext),
+                  right.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
         return createErrorConstant(
@@ -2558,7 +2590,7 @@
           templateConstEvalInvalidType.withArguments(
               condition,
               typeEnvironment.coreTypes.boolLegacyRawType,
-              condition.getType(_staticTypeContext),
+              condition.getType(_staticTypeContext!),
               isNonNullableByDefault));
     }
   }
@@ -2573,9 +2605,11 @@
         return createErrorConstant(node, messageNotAConstantExpression);
       }
 
-      for (final Field field in instanceBuilder.fields.keys) {
+      for (final MapEntry<Field, Constant> entry
+          in instanceBuilder!.fields.entries) {
+        final Field field = entry.key;
         if (field.name == node.name) {
-          return instanceBuilder.fields[field];
+          return entry.value;
         }
       }
 
@@ -2631,10 +2665,11 @@
           return receiver.entries.single;
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
-      for (final Reference fieldRef in receiver.fieldValues.keys) {
-        final Field field = fieldRef.asField;
+      for (final MapEntry<Reference, Constant> entry
+          in receiver.fieldValues.entries) {
+        final Field field = entry.key.asField;
         if (field.name == node.name) {
-          return receiver.fieldValues[fieldRef];
+          return entry.value;
         }
       }
     }
@@ -2692,9 +2727,11 @@
         return createErrorConstant(node, messageNotAConstantExpression);
       }
 
-      for (final Field field in instanceBuilder.fields.keys) {
+      for (final MapEntry<Field, Constant> entry
+          in instanceBuilder!.fields.entries) {
+        final Field field = entry.key;
         if (field.name == node.name) {
-          return instanceBuilder.fields[field];
+          return entry.value;
         }
       }
 
@@ -2747,10 +2784,11 @@
           return receiver.entries.single;
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
-      for (final Reference fieldRef in receiver.fieldValues.keys) {
-        final Field field = fieldRef.asField;
+      for (final MapEntry<Reference, Constant> entry
+          in receiver.fieldValues.entries) {
+        final Field field = entry.key.asField;
         if (field.name == node.name) {
-          return receiver.fieldValues[fieldRef];
+          return entry.value;
         }
       }
     }
@@ -2762,7 +2800,7 @@
 
   @override
   Constant visitLet(Let node) {
-    Constant value = _evaluateSubexpression(node.variable.initializer);
+    Constant value = _evaluateSubexpression(node.variable.initializer!);
     if (value is AbortConstant) return value;
     env.addVariableValue(node.variable, value);
     return _evaluateSubexpression(node.body);
@@ -2779,18 +2817,20 @@
     final VariableDeclaration variable = node.variable;
     if (enableConstFunctions) {
       return env.lookupVariable(variable) ??
-          createErrorConstant(node,
-              templateConstEvalGetterNotFound.withArguments(variable.name));
+          createErrorConstant(
+              node,
+              templateConstEvalGetterNotFound
+                  .withArguments(variable.name ?? ''));
     } else {
       if (variable.parent is Let || _isFormalParameter(variable)) {
         return env.lookupVariable(node.variable) ??
             createErrorConstant(
                 node,
                 templateConstEvalNonConstantVariableGet
-                    .withArguments(variable.name));
+                    .withArguments(variable.name ?? ''));
       }
       if (variable.isConst) {
-        return _evaluateSubexpression(variable.initializer);
+        return _evaluateSubexpression(variable.initializer!);
       }
     }
     return createInvalidExpressionConstant(
@@ -2816,11 +2856,11 @@
   /// the constant is defined in a library compiled with the agnostic evaluation
   /// mode.
   Constant _evaluateExpressionInContext(Member member, Expression expression) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(member, typeEnvironment);
     Constant constant = _evaluateSubexpression(expression);
     if (constant is! AbortConstant) {
-      if (_staticTypeContext.nonNullableByDefaultCompiledMode ==
+      if (_staticTypeContext!.nonNullableByDefaultCompiledMode ==
               NonNullableByDefaultCompiledMode.Agnostic &&
           evaluationMode == EvaluationMode.weak) {
         constant = _weakener.visitConstant(constant) ?? constant;
@@ -2836,7 +2876,7 @@
       final Member target = node.target;
       if (target is Field) {
         if (target.isConst) {
-          return _evaluateExpressionInContext(target, target.initializer);
+          return _evaluateExpressionInContext(target, target.initializer!);
         }
         return createErrorConstant(
             node,
@@ -2909,18 +2949,17 @@
     }
     if (concatenated.length > 1) {
       final List<Expression> expressions =
-          new List<Expression>.filled(concatenated.length, null);
-      for (int i = 0; i < concatenated.length; i++) {
+          new List<Expression>.generate(concatenated.length, (int i) {
         Object value = concatenated[i];
         if (value is StringBuffer) {
-          expressions[i] = new ConstantExpression(
+          return new ConstantExpression(
               canonicalize(new StringConstant(value.toString())));
         } else {
           // The value is either unevaluated constant or a non-primitive
           // constant in an unevaluated expression.
-          expressions[i] = extract(value);
+          return extract(value as Constant);
         }
-      }
+      }, growable: false);
       return unevaluated(node, new StringConcatenation(expressions));
     }
     return canonicalize(new StringConstant(concatenated.single.toString()));
@@ -2930,7 +2969,7 @@
     VariableDeclaration variable = target.function.namedParameters
         .singleWhere((v) => v.name == 'defaultValue');
     return variable.initializer != null
-        ? _evaluateExpressionInContext(target, variable.initializer)
+        ? _evaluateExpressionInContext(target, variable.initializer!)
         :
         // Not reachable unless a defaultValue in fromEnvironment in dart:core
         // becomes null.
@@ -2939,8 +2978,8 @@
 
   Constant _handleFromEnvironment(
       Procedure target, StringConstant name, Map<String, Constant> named) {
-    String value = environmentDefines[name.value];
-    Constant defaultValue = named["defaultValue"];
+    String? value = environmentDefines![name.value];
+    Constant? defaultValue = named["defaultValue"];
     if (target.enclosingClass == coreTypes.boolClass) {
       Constant boolConstant;
       if (value == "true") {
@@ -2961,10 +3000,10 @@
       }
       return boolConstant;
     } else if (target.enclosingClass == coreTypes.intClass) {
-      int intValue = value != null ? int.tryParse(value) : null;
+      int? intValue = value != null ? int.tryParse(value) : null;
       Constant intConstant;
       if (intValue != null) {
-        bool negated = value.startsWith('-');
+        bool negated = value!.startsWith('-');
         intConstant = intFolder.makeIntConstant(intValue, unsigned: !negated);
       } else if (defaultValue != null) {
         if (intFolder.isInt(defaultValue)) {
@@ -2998,7 +3037,7 @@
   }
 
   Constant _handleHasEnvironment(StringConstant name) {
-    return environmentDefines.containsKey(name.value)
+    return environmentDefines!.containsKey(name.value)
         ? trueConstant
         : falseConstant;
   }
@@ -3007,33 +3046,36 @@
   Constant visitStaticInvocation(StaticInvocation node) {
     final Procedure target = node.target;
     final Arguments arguments = node.arguments;
-    List<DartType> types = _evaluateTypeArguments(node, arguments);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, arguments);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     final List<DartType> typeArguments = convertTypes(types);
 
-    final List<Constant> positionals = _evaluatePositionalArguments(arguments);
-    if (positionals == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final List<Constant>? positionals = _evaluatePositionalArguments(arguments);
+    if (positionals == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(positionals != null);
 
-    final Map<String, Constant> named = _evaluateNamedArguments(arguments);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named = _evaluateNamedArguments(arguments);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     if (shouldBeUnevaluated) {
@@ -3072,7 +3114,7 @@
       }
     } else if (target.name.text == 'identical') {
       // Ensure the "identical()" function comes from dart:core.
-      final TreeNode parent = target.parent;
+      final TreeNode? parent = target.parent;
       if (parent is Library && parent == coreTypes.coreLibrary) {
         final Constant left = positionals[0];
         final Constant right = positionals[1];
@@ -3082,8 +3124,8 @@
           // identical here.
           Constant result = makeBoolConstant(identical(left, right));
           if (evaluationMode == EvaluationMode.agnostic) {
-            Constant weakLeft = _weakener.visitConstant(left);
-            Constant weakRight = _weakener.visitConstant(right);
+            Constant? weakLeft = _weakener.visitConstant(left);
+            Constant? weakRight = _weakener.visitConstant(right);
             if (weakLeft != null || weakRight != null) {
               Constant weakResult = makeBoolConstant(
                   identical(weakLeft ?? left, weakRight ?? right));
@@ -3112,9 +3154,9 @@
     String name = target.name.text;
     if (target is Procedure && target.isFactory) {
       if (name.isEmpty) {
-        name = target.enclosingClass.name;
+        name = target.enclosingClass!.name;
       } else {
-        name = '${target.enclosingClass.name}.${name}';
+        name = '${target.enclosingClass!.name}.${name}';
       }
 
       if (enableConstFunctions) {
@@ -3130,7 +3172,7 @@
       List<DartType> typeArguments,
       List<Constant> positionalArguments,
       Map<String, Constant> namedArguments,
-      {EvaluationEnvironment functionEnvironment}) {
+      {EvaluationEnvironment? functionEnvironment}) {
     Constant executeFunction() {
       // Map arguments from caller to callee.
       for (int i = 0; i < function.typeParameters.length; i++) {
@@ -3153,7 +3195,7 @@
         env.addVariableValue(parameter, value);
       }
 
-      final Constant result = executeBody(function.body);
+      final Constant result = executeBody(function.body!);
       if (result is NullConstant &&
           function.returnType.nullability == Nullability.nonNullable) {
         // Ensure that the evaluated constant returned is not null if the
@@ -3163,7 +3205,7 @@
             templateConstEvalInvalidType.withArguments(
                 result,
                 function.returnType,
-                result.getType(_staticTypeContext),
+                result.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
       return result;
@@ -3184,15 +3226,16 @@
           node,
           new AsExpression(extract(constant), env.substituteType(node.type))
             ..isForNonNullableByDefault =
-                _staticTypeContext.isNonNullableByDefault);
+                _staticTypeContext!.isNonNullableByDefault);
     }
-    DartType type = _evaluateDartType(node, node.type);
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    DartType? type = _evaluateDartType(node, node.type);
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
     return ensureIsSubtype(constant, type, node);
   }
@@ -3209,16 +3252,18 @@
             ..flags = node.flags);
     }
 
-    DartType type = _evaluateDartType(node, node.type);
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    DartType? type = _evaluateDartType(node, node.type);
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
 
-    bool performIs(Constant constant, {bool strongMode}) {
+    bool performIs(Constant constant, {required bool strongMode}) {
+      // ignore: unnecessary_null_comparison
       assert(strongMode != null);
       if (strongMode) {
         return isSubtype(constant, type, SubtypeCheckMode.withNullabilities);
@@ -3263,7 +3308,6 @@
       case EvaluationMode.weak:
         return makeBoolConstant(performIs(constant, strongMode: false));
     }
-    throw new UnsupportedError("Unexpected evaluation mode $evaluationMode");
   }
 
   @override
@@ -3281,7 +3325,7 @@
         templateConstEvalInvalidType.withArguments(
             constant,
             typeEnvironment.coreTypes.boolLegacyRawType,
-            constant.getType(_staticTypeContext),
+            constant.getType(_staticTypeContext!),
             isNonNullableByDefault));
   }
 
@@ -3300,7 +3344,7 @@
 
   @override
   Constant visitSymbolLiteral(SymbolLiteral node) {
-    final Reference libraryReference =
+    final Reference? libraryReference =
         node.value.startsWith('_') ? libraryOf(node).reference : null;
     return canonicalize(new SymbolConstant(node.value, libraryReference));
   }
@@ -3328,13 +3372,14 @@
     if (constant is TearOffConstant) {
       if (node.typeArguments.length ==
           constant.procedure.function.typeParameters.length) {
-        List<DartType> types = _evaluateDartTypes(node, node.typeArguments);
-        if (types == null && _gotError != null) {
-          AbortConstant error = _gotError;
+        List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
+        if (types == null) {
+          AbortConstant error = _gotError!;
           _gotError = null;
           return error;
         }
         assert(_gotError == null);
+        // ignore: unnecessary_null_comparison
         assert(types != null);
 
         final List<DartType> typeArguments = convertTypes(types);
@@ -3356,8 +3401,8 @@
 
   @override
   Constant visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
-    return createErrorConstant(
-        node, templateConstEvalDeferredLibrary.withArguments(node.import.name));
+    return createErrorConstant(node,
+        templateConstEvalDeferredLibrary.withArguments(node.import.name!));
   }
 
   // Helper methods:
@@ -3365,7 +3410,7 @@
   /// If both constants are DoubleConstant whose values would give different
   /// results from == and [identical], return the result of ==. Otherwise
   /// return null.
-  Constant doubleSpecialCases(Constant a, Constant b) {
+  Constant? doubleSpecialCases(Constant a, Constant b) {
     if (a is DoubleConstant && b is DoubleConstant) {
       if (a.value.isNaN && b.value.isNaN) return falseConstant;
       if (a.value == 0.0 && b.value == 0.0) return trueConstant;
@@ -3383,12 +3428,12 @@
 
   bool hasPrimitiveEqual(Constant constant) {
     if (intFolder.isInt(constant)) return true;
-    DartType type = constant.getType(_staticTypeContext);
+    DartType type = constant.getType(_staticTypeContext!);
     return !(type is InterfaceType && !classHasPrimitiveEqual(type.classNode));
   }
 
   bool classHasPrimitiveEqual(Class klass) {
-    bool cached = primitiveEqualCache[klass];
+    bool? cached = primitiveEqualCache[klass];
     if (cached != null) return cached;
     for (Procedure procedure in klass.procedures) {
       if (procedure.kind == ProcedureKind.Operator &&
@@ -3400,14 +3445,14 @@
     }
     if (klass.supertype == null) return true; // To be on the safe side
     return primitiveEqualCache[klass] =
-        classHasPrimitiveEqual(klass.supertype.classNode);
+        classHasPrimitiveEqual(klass.supertype!.classNode);
   }
 
   BoolConstant makeBoolConstant(bool value) =>
       value ? trueConstant : falseConstant;
 
   bool isSubtype(Constant constant, DartType type, SubtypeCheckMode mode) {
-    DartType constantType = constant.getType(_staticTypeContext);
+    DartType constantType = constant.getType(_staticTypeContext!);
     if (mode == SubtypeCheckMode.ignoringNullabilities) {
       constantType = rawLegacyErasure(constantType) ?? constantType;
     }
@@ -3462,20 +3507,20 @@
       return createErrorConstant(
           node,
           templateConstEvalInvalidType.withArguments(constant, type,
-              constant.getType(_staticTypeContext), isNonNullableByDefault));
+              constant.getType(_staticTypeContext!), isNonNullableByDefault));
     }
     return constant;
   }
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateTypeArguments(TreeNode node, Arguments arguments) {
+  List<DartType>? _evaluateTypeArguments(TreeNode node, Arguments arguments) {
     return _evaluateDartTypes(node, arguments.types);
   }
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateSuperTypeArguments(TreeNode node, Supertype type) {
+  List<DartType>? _evaluateSuperTypeArguments(TreeNode node, Supertype type) {
     return _evaluateDartTypes(node, type.typeArguments);
   }
 
@@ -3483,22 +3528,23 @@
   /// "error"-constant is saved here. Normally this should be null.
   /// Once a caller calls such a procedure and it gives an error here,
   /// the caller should fetch it an null-out this variable.
-  AbortConstant _gotError;
+  AbortConstant? _gotError;
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateDartTypes(TreeNode node, List<DartType> types) {
+  List<DartType>? _evaluateDartTypes(TreeNode node, List<DartType> types) {
     // TODO: Once the frontend guarantees that there are no free type variables
     // left over after substitution, we can enable this shortcut again:
     // if (env.isEmpty) return types;
     List<DartType> result =
-        new List<DartType>.filled(types.length, null, growable: true);
+        new List<DartType>.filled(types.length, dummyDartType, growable: true);
     for (int i = 0; i < types.length; i++) {
-      DartType type = _evaluateDartType(node, types[i]);
-      if (type == null && _gotError != null) {
+      DartType? type = _evaluateDartType(node, types[i]);
+      if (type == null) {
         return null;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(type != null);
       result[i] = type;
     }
@@ -3507,7 +3553,7 @@
 
   /// Returns the type on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  DartType _evaluateDartType(TreeNode node, DartType type) {
+  DartType? _evaluateDartType(TreeNode node, DartType type) {
     final DartType result = env.substituteType(type);
 
     if (!isInstantiated(result)) {
@@ -3523,9 +3569,9 @@
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<Constant> _evaluatePositionalArguments(Arguments arguments) {
+  List<Constant>? _evaluatePositionalArguments(Arguments arguments) {
     List<Constant> result = new List<Constant>.filled(
-        arguments.positional.length, null,
+        arguments.positional.length, dummyConstant,
         growable: true);
     for (int i = 0; i < arguments.positional.length; i++) {
       Constant constant = _evaluateSubexpression(arguments.positional[i]);
@@ -3540,7 +3586,7 @@
 
   /// Returns the arguments on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  Map<String, Constant> _evaluateNamedArguments(Arguments arguments) {
+  Map<String, Constant>? _evaluateNamedArguments(Arguments arguments) {
     if (arguments.named.isEmpty) return const <String, Constant>{};
 
     final Map<String, Constant> named = {};
@@ -3560,9 +3606,9 @@
   Arguments unevaluatedArguments(List<Constant> positionalArgs,
       Map<String, Constant> namedArgs, List<DartType> types) {
     final List<Expression> positional =
-        new List<Expression>.filled(positionalArgs.length, null);
-    final List<NamedExpression> named =
-        new List<NamedExpression>.filled(namedArgs.length, null);
+        new List<Expression>.filled(positionalArgs.length, dummyExpression);
+    final List<NamedExpression> named = new List<NamedExpression>.filled(
+        namedArgs.length, dummyNamedExpression);
     for (int i = 0; i < positionalArgs.length; ++i) {
       positional[i] = extract(positionalArgs[i]);
     }
@@ -3581,7 +3627,7 @@
 
   T withNewInstanceBuilder<T>(
       Class klass, List<DartType> typeArguments, T fn()) {
-    InstanceBuilder old = instanceBuilder;
+    InstanceBuilder? old = instanceBuilder;
     instanceBuilder = new InstanceBuilder(this, klass, typeArguments);
     T result = fn();
     instanceBuilder = old;
@@ -3610,14 +3656,14 @@
 
   /// Binary operation between two operands, at least one of which is a double.
   Constant evaluateBinaryNumericOperation(
-      String op, num a, num b, TreeNode node) {
+      String op, num a, num b, Expression node) {
     switch (op) {
       case '+':
-        return new DoubleConstant(a + b);
+        return new DoubleConstant((a + b) as double);
       case '-':
-        return new DoubleConstant(a - b);
+        return new DoubleConstant((a - b) as double);
       case '*':
-        return new DoubleConstant(a * b);
+        return new DoubleConstant((a * b) as double);
       case '/':
         return new DoubleConstant(a / b);
       case '~/':
@@ -3627,7 +3673,7 @@
         }
         return intFolder.truncatingDivide(node, a, b);
       case '%':
-        return new DoubleConstant(a % b);
+        return new DoubleConstant((a % b) as double);
     }
 
     switch (op) {
@@ -3646,12 +3692,14 @@
         node, "Unexpected binary numeric operation '$op'.");
   }
 
-  Library libraryOf(TreeNode node) {
+  // TODO(johnniwinther): Remove the need for this by adding a current library
+  // field.
+  Library libraryOf(TreeNode? node) {
     // The tree structure of the kernel AST ensures we always have an enclosing
     // library.
     while (true) {
       if (node is Library) return node;
-      node = node.parent;
+      node = node!.parent;
     }
   }
 
@@ -3727,7 +3775,7 @@
 
   @override
   ExecutionStatus visitAssertStatement(AssertStatement node) {
-    AbortConstant error = exprEvaluator.checkAssert(node);
+    AbortConstant? error = exprEvaluator.checkAssert(node);
     if (error != null) return new AbortStatus(error);
     return const ProceedStatus();
   }
@@ -3790,7 +3838,7 @@
     if ((condition as BoolConstant).value) {
       return node.then.accept(this);
     } else if (node.otherwise != null) {
-      return node.otherwise.accept(this);
+      return node.otherwise!.accept(this);
     }
     return const ProceedStatus();
   }
@@ -3802,8 +3850,8 @@
       if (status is! ProceedStatus) return status;
     }
 
-    Constant condition =
-        node.condition != null ? evaluate(node.condition) : null;
+    Constant? condition =
+        node.condition != null ? evaluate(node.condition!) : null;
     while (node.condition == null || condition is BoolConstant) {
       if (condition is BoolConstant && !condition.value) break;
 
@@ -3818,7 +3866,7 @@
       }
 
       if (node.condition != null) {
-        condition = evaluate(node.condition);
+        condition = evaluate(node.condition!);
       }
     }
 
@@ -3845,9 +3893,9 @@
 
   @override
   ExecutionStatus visitReturnStatement(ReturnStatement node) {
-    Constant result;
+    Constant? result;
     if (node.expression != null) {
-      result = evaluate(node.expression);
+      result = evaluate(node.expression!);
       if (result is AbortConstant) return new AbortStatus(result);
     }
     return new ReturnStatus(result);
@@ -3878,9 +3926,9 @@
         final DartType defaultType =
             exprEvaluator.typeEnvironment.coreTypes.objectNonNullableRawType;
 
-        DartType throwType;
+        DartType? throwType;
         if (throwValue is Constant) {
-          throwType = throwValue.getType(exprEvaluator._staticTypeContext);
+          throwType = throwValue.getType(exprEvaluator._staticTypeContext!);
         } else if (throwValue is StateError) {
           final Class stateErrorClass = exprEvaluator
               .coreTypes.coreLibrary.classes
@@ -3897,7 +3945,7 @@
         assert(throwType != null);
 
         for (Catch catchClause in node.catches) {
-          if (exprEvaluator.typeEnvironment.isSubtypeOf(throwType,
+          if (exprEvaluator.typeEnvironment.isSubtypeOf(throwType!,
                   catchClause.guard, SubtypeCheckMode.withNullabilities) ||
               catchClause.guard == defaultType) {
             return exprEvaluator.withNewEnvironment(() {
@@ -3905,7 +3953,7 @@
                 // TODO(kallentu): Store non-constant exceptions.
                 if (throwValue is Constant) {
                   exprEvaluator.env
-                      .addVariableValue(catchClause.exception, throwValue);
+                      .addVariableValue(catchClause.exception!, throwValue);
                 }
               }
               // TODO(kallentu): Store appropriate stack trace in environment.
@@ -3930,7 +3978,7 @@
   ExecutionStatus visitVariableDeclaration(VariableDeclaration node) {
     Constant value;
     if (node.initializer != null) {
-      value = evaluate(node.initializer);
+      value = evaluate(node.initializer!);
       if (value is AbortConstant) return new AbortStatus(value);
     } else {
       value = new NullConstant();
@@ -4024,16 +4072,16 @@
   final Set<VariableDeclaration> _unreadUnevaluatedVariables =
       new Set<VariableDeclaration>();
 
-  EvaluationEnvironment _parent;
+  final EvaluationEnvironment? _parent;
 
-  EvaluationEnvironment();
+  EvaluationEnvironment() : _parent = null;
   EvaluationEnvironment.withParent(this._parent);
 
   /// Whether the current environment is empty.
   bool get isEmpty {
     // Since we look up variables in enclosing environment, the environment
     // is not empty if its parent is not empty.
-    if (_parent != null && !_parent.isEmpty) return false;
+    if (_parent != null && !_parent!.isEmpty) return false;
     return _typeVariables.isEmpty && _variables.isEmpty;
   }
 
@@ -4049,16 +4097,17 @@
     }
   }
 
-  Constant updateVariableValue(VariableDeclaration variable, Constant value) {
-    if (_variables.containsKey(variable)) {
-      _variables[variable].value = value;
+  Constant? updateVariableValue(VariableDeclaration variable, Constant value) {
+    EvaluationReference? reference = _variables[variable];
+    if (reference != null) {
+      reference.value = value;
       return value;
     }
     return _parent?.updateVariableValue(variable, value);
   }
 
-  Constant lookupVariable(VariableDeclaration variable) {
-    Constant value = _variables[variable]?.value;
+  Constant? lookupVariable(VariableDeclaration variable) {
+    Constant? value = _variables[variable]?.value;
     if (value is UnevaluatedConstant) {
       _unreadUnevaluatedVariables.remove(variable);
     } else if (value == null) {
@@ -4071,7 +4120,8 @@
   Iterable<UnevaluatedConstant> get unevaluatedUnreadConstants {
     if (_unreadUnevaluatedVariables.isEmpty) return const [];
     return _unreadUnevaluatedVariables.map<UnevaluatedConstant>(
-        (VariableDeclaration variable) => _variables[variable].value);
+        (VariableDeclaration variable) =>
+            _variables[variable]!.value as UnevaluatedConstant);
   }
 
   DartType substituteType(DartType type) {
@@ -4079,23 +4129,22 @@
     final DartType substitutedType = substitute(type, _typeVariables);
     if (identical(substitutedType, type) && _parent != null) {
       // No distinct type created, substitute type in parent.
-      return _parent.substituteType(type);
+      return _parent!.substituteType(type);
     }
     return substitutedType;
   }
 }
 
 class RedundantFileUriExpressionRemover extends Transformer {
-  Uri currentFileUri = null;
+  Uri? currentFileUri = null;
 
   TreeNode visitFileUriExpression(FileUriExpression node) {
     if (node.fileUri == currentFileUri) {
       return node.expression.accept(this);
     } else {
-      Uri oldFileUri = currentFileUri;
+      Uri? oldFileUri = currentFileUri;
       currentFileUri = node.fileUri;
-      node.expression = node.expression.accept(this) as Expression
-        ..parent = node;
+      node.expression = transform(node.expression)..parent = node;
       currentFileUri = oldFileUri;
       return node;
     }
@@ -4121,7 +4170,7 @@
 
 /// Status that the statement returned a valid [Constant] value.
 class ReturnStatus extends ExecutionStatus {
-  final Constant value;
+  final Constant? value;
   ReturnStatus(this.value);
 }
 
@@ -4150,7 +4199,7 @@
 /// respective environment within the [ConstantEvaluator].
 class FunctionValue implements Constant {
   final FunctionNode function;
-  final EvaluationEnvironment environment;
+  final EvaluationEnvironment? environment;
 
   FunctionValue(this.function, this.environment);
 
@@ -4210,7 +4259,7 @@
 class _AbortDueToErrorConstant extends AbortConstant {
   final TreeNode node;
   final Message message;
-  final List<LocatedMessage> context;
+  final List<LocatedMessage>? context;
 
   _AbortDueToErrorConstant(this.node, this.message, {this.context});
 
@@ -4382,7 +4431,7 @@
 abstract class ErrorReporter {
   const ErrorReporter();
 
-  void report(LocatedMessage message, List<LocatedMessage> context);
+  void report(LocatedMessage message, List<LocatedMessage>? context);
 
   void reportInvalidExpression(InvalidExpression node);
 }
@@ -4391,10 +4440,12 @@
   const SimpleErrorReporter();
 
   @override
-  void report(LocatedMessage message, List<LocatedMessage> context) {
+  void report(LocatedMessage message, List<LocatedMessage>? context) {
     _report(message);
-    for (LocatedMessage contextMessage in context) {
-      _report(contextMessage);
+    if (context != null) {
+      for (LocatedMessage contextMessage in context) {
+        _report(contextMessage);
+      }
     }
   }
 
@@ -4407,7 +4458,7 @@
     reportMessage(message.uri, message.charOffset, message.message);
   }
 
-  void reportMessage(Uri uri, int offset, String message) {
+  void reportMessage(Uri? uri, int offset, String message) {
     io.exitCode = 42;
     io.stderr.writeln('$uri:$offset Constant evaluation error: $message');
   }
@@ -4476,7 +4527,7 @@
 }
 
 bool _isFormalParameter(VariableDeclaration variable) {
-  final TreeNode parent = variable.parent;
+  final TreeNode? parent = variable.parent;
   if (parent is FunctionNode) {
     return parent.positionalParameters.contains(variable) ||
         parent.namedParameters.contains(variable);
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart b/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart
index fbbd0ca..8ffd6f5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart
@@ -2,8 +2,6 @@
 // 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.
 
-// @dart = 2.9
-
 import 'package:kernel/ast.dart';
 import 'package:kernel/target/targets.dart';
 
@@ -29,8 +27,16 @@
     }
   }
 
+  /// Returns `true` of [constant] is an integer value.
   bool isInt(Constant constant);
 
+  /// Returns the value of [constant] as an [int], of `null` [constant] is
+  /// not an integer value.
+  ///
+  /// This method must return a non-null value iff `isInt(constant)` returns
+  /// `true`.
+  int? asInt(Constant constant);
+
   Constant makeIntConstant(int value, {bool unsigned: false});
 
   Constant foldUnaryOperator(
@@ -43,7 +49,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant _checkOperands(
+  AbortConstant? _checkOperands(
       Expression node, String op, num left, num right) {
     if ((op == '<<' || op == '>>' || op == '>>>') && right < 0) {
       return evaluator.createErrorConstant(node,
@@ -64,6 +70,14 @@
   bool isInt(Constant constant) => constant is IntConstant;
 
   @override
+  int? asInt(Constant constant) {
+    if (constant is IntConstant) {
+      return constant.value;
+    }
+    return null;
+  }
+
+  @override
   IntConstant makeIntConstant(int value, {bool unsigned: false}) {
     return new IntConstant(value);
   }
@@ -87,7 +101,7 @@
       Expression node, String op, IntConstant left, IntConstant right) {
     int a = left.value;
     int b = right.value;
-    AbortConstant error = _checkOperands(node, op, a, b);
+    AbortConstant? error = _checkOperands(node, op, a, b);
     if (error != null) return error;
     switch (op) {
       case '+':
@@ -161,6 +175,14 @@
   }
 
   @override
+  int? asInt(Constant constant) {
+    if (constant is DoubleConstant && _valueIsInteger(constant.value)) {
+      return constant.value.toInt();
+    }
+    return null;
+  }
+
+  @override
   DoubleConstant makeIntConstant(int value, {bool unsigned: false}) {
     double doubleValue = value.toDouble();
     // Invalid assert: assert(doubleValue.toInt() == value);
@@ -192,7 +214,7 @@
       Expression node, String op, DoubleConstant left, DoubleConstant right) {
     double a = left.value;
     double b = right.value;
-    AbortConstant error = _checkOperands(node, op, a, b);
+    AbortConstant? error = _checkOperands(node, op, a, b);
     if (error != null) return error;
     switch (op) {
       case '+':
diff --git a/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart b/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
index 1424749..7ea0645 100644
--- a/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
+++ b/pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
@@ -17,12 +17,8 @@
 
 // THIS FILE IS AUTO GENERATED BY
 // 'tool/_fasta/direct_parser_ast_helper_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart \
-      > pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart'
 
 abstract class DirectParserASTContent {
   final String what;
diff --git a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
index 2bc0bed..0f6b7b2 100644
--- a/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/await_not_in_async.dart.intertwined.expect
@@ -36,6 +36,7 @@
                   parsePrimary(=>, expression)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
+                        isNextIdentifier(=>)
                         ensureIdentifier(=>, expression)
                           listener: handleIdentifier(Future, expression)
                         listener: handleNoTypeArguments(.)
@@ -46,6 +47,7 @@
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     looksLikeFunctionBody(;)
                     parseSend(., expressionContinuation)
+                      isNextIdentifier(.)
                       ensureIdentifier(., expressionContinuation)
                         listener: handleIdentifier(value, expressionContinuation)
                       listener: handleNoTypeArguments(()
@@ -105,6 +107,7 @@
                               parseSendOrFunctionLiteral(await, expression)
                                 looksLikeFunctionBody(;)
                                 parseSend(await, expression)
+                                  isNextIdentifier(await)
                                   ensureIdentifier(await, expression)
                                     listener: handleIdentifier(f, expression)
                                   listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
index 091a47f..11a6354 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_00.dart.intertwined.expect
@@ -111,6 +111,7 @@
                                                   parseUnaryExpression((, true)
                                                     parsePrimary((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                                             listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
index a41ebf5..0b1eeb0 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_01.dart.intertwined.expect
@@ -111,6 +111,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(C, expression)
                                     listener: handleNoTypeArguments(()
@@ -133,6 +134,7 @@
                                                             parseSendOrFunctionLiteral([, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend([, expression)
+                                                                isNextIdentifier([)
                                                                 ensureIdentifier([, expression)
                                                                   listener: handleIdentifier(C, expression)
                                                                 listener: handleNoTypeArguments(()
@@ -155,6 +157,7 @@
                                                                                         parseSendOrFunctionLiteral([, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend([, expression)
+                                                                                            isNextIdentifier([)
                                                                                             ensureIdentifier([, expression)
                                                                                               listener: handleIdentifier(C, expression)
                                                                                             listener: handleNoTypeArguments(()
@@ -171,6 +174,7 @@
                                                                                         parseSendOrFunctionLiteral(,, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend(,, expression)
+                                                                                            isNextIdentifier(,)
                                                                                             ensureIdentifier(,, expression)
                                                                                               listener: handleIdentifier(C, expression)
                                                                                             listener: handleNoTypeArguments(()
@@ -187,6 +191,7 @@
                                                                                         parseSendOrFunctionLiteral(,, expression)
                                                                                           looksLikeFunctionBody(,)
                                                                                           parseSend(,, expression)
+                                                                                            isNextIdentifier(,)
                                                                                             ensureIdentifier(,, expression)
                                                                                               listener: handleIdentifier(C, expression)
                                                                                             listener: handleNoTypeArguments(()
@@ -207,6 +212,7 @@
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
+                                                                isNextIdentifier(,)
                                                                 ensureIdentifier(,, expression)
                                                                   listener: handleIdentifier(C, expression)
                                                                 listener: handleNoTypeArguments(()
@@ -223,6 +229,7 @@
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
+                                                                isNextIdentifier(,)
                                                                 ensureIdentifier(,, expression)
                                                                   listener: handleIdentifier(C, expression)
                                                                 listener: handleNoTypeArguments(()
@@ -356,6 +363,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(D, expression)
                                     listener: handleNoTypeArguments(()
@@ -378,6 +386,7 @@
                                                             parseSendOrFunctionLiteral([, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend([, expression)
+                                                                isNextIdentifier([)
                                                                 ensureIdentifier([, expression)
                                                                   listener: handleIdentifier(D, expression)
                                                                 listener: handleNoTypeArguments(()
@@ -394,6 +403,7 @@
                                                                               parseSendOrFunctionLiteral(:, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(:, expression)
+                                                                                  isNextIdentifier(:)
                                                                                   ensureIdentifier(:, expression)
                                                                                     listener: handleIdentifier(D, expression)
                                                                                   listener: handleNoTypeArguments(()
@@ -413,6 +423,7 @@
                                                                               parseSendOrFunctionLiteral(,, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(,, expression)
+                                                                                  isNextIdentifier(,)
                                                                                   ensureIdentifier(,, expression)
                                                                                     listener: handleIdentifier(D, expression)
                                                                                   listener: handleNoTypeArguments(()
@@ -431,6 +442,7 @@
                                                                               parseSendOrFunctionLiteral(,, expression)
                                                                                 looksLikeFunctionBody(,)
                                                                                 parseSend(,, expression)
+                                                                                  isNextIdentifier(,)
                                                                                   ensureIdentifier(,, expression)
                                                                                     listener: handleIdentifier(D, expression)
                                                                                   listener: handleNoTypeArguments(()
@@ -447,6 +459,7 @@
                                                                           parseUnaryExpression(,, true)
                                                                             parsePrimary(,, expression)
                                                                               parseSend(,, expression)
+                                                                                isNextIdentifier(,)
                                                                                 ensureIdentifier(,, expression)
                                                                                   reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                                                                     listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
@@ -468,6 +481,7 @@
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
+                                                                isNextIdentifier(,)
                                                                 ensureIdentifier(,, expression)
                                                                   listener: handleIdentifier(D, expression)
                                                                 listener: handleNoTypeArguments(()
@@ -484,6 +498,7 @@
                                                             parseSendOrFunctionLiteral(,, expression)
                                                               looksLikeFunctionBody(,)
                                                               parseSend(,, expression)
+                                                                isNextIdentifier(,)
                                                                 ensureIdentifier(,, expression)
                                                                   listener: handleIdentifier(D, expression)
                                                                 listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
index 787bbaa..b4f350e 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_03.dart.intertwined.expect
@@ -44,6 +44,7 @@
                                 parseSendOrFunctionLiteral({, expression)
                                   looksLikeFunctionBody())
                                   parseSend({, expression)
+                                    isNextIdentifier({)
                                     ensureIdentifier({, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(()
@@ -70,6 +71,7 @@
                               parseUnaryExpression(;, true)
                                 parsePrimary(;, expression)
                                   parseSend(;, expression)
+                                    isNextIdentifier(;)
                                     ensureIdentifier(;, expression)
                                       reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                         listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
index a3b498e..5dee028 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_04.dart.intertwined.expect
@@ -38,6 +38,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(()
@@ -76,6 +77,7 @@
                                                                     parseSendOrFunctionLiteral({, expression)
                                                                       looksLikeFunctionBody())
                                                                       parseSend({, expression)
+                                                                        isNextIdentifier({)
                                                                         ensureIdentifier({, expression)
                                                                           listener: handleIdentifier(bar, expression)
                                                                         listener: handleNoTypeArguments(()
@@ -102,6 +104,7 @@
                                                                   parseUnaryExpression(;, true)
                                                                     parsePrimary(;, expression)
                                                                       parseSend(;, expression)
+                                                                        isNextIdentifier(;)
                                                                         ensureIdentifier(;, expression)
                                                                           reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                                                             listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
diff --git a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
index 0964dbc..1367408 100644
--- a/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/bracket_mismatch_06.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parseUnaryExpression({, true)
                           parsePrimary({, expression)
                             parseNewExpression({)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -55,6 +56,7 @@
                                       parseUnaryExpression((, true)
                                         parsePrimary((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               reportRecoverableErrorWithToken(;, Instance of 'Template<(Token) => Message>')
                                                 listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ';'., Try inserting an identifier before ';'., {lexeme: ;}], ;, ;)
diff --git a/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
index 4c19be1..cace6c4 100644
--- a/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/comment_on_non_ascii_identifier.dart.intertwined.expect
@@ -123,6 +123,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -136,6 +137,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(æFoo, expression)
                                                 listener: handleNoTypeArguments())
@@ -159,6 +161,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -172,6 +175,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(fooÆ, expression)
                                                 listener: handleNoTypeArguments())
@@ -195,6 +199,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -208,6 +213,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(foo, expression)
                                                 listener: handleNoTypeArguments())
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
index 4b28f49..a652954 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_general.crash_dart.intertwined.expect
@@ -100,6 +100,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -158,6 +159,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -399,6 +401,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
@@ -470,6 +473,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
@@ -738,6 +742,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
@@ -809,6 +814,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
@@ -882,6 +888,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
@@ -942,6 +949,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(bla, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
index 6b6b94b..4180073 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_get.crash_dart.intertwined.expect
@@ -99,6 +99,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -160,6 +161,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
index 960ba0b..69f5eb9 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_return_type.crash_dart.intertwined.expect
@@ -100,6 +100,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -159,6 +160,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
index 5b09d19..2950a4b 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_bad_name_set.crash_dart.intertwined.expect
@@ -99,6 +99,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -158,6 +159,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
index f618dcd..2b05409 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_get.dart.intertwined.expect
@@ -93,6 +93,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -191,6 +192,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
index 07a34d8..9a4c31d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_ok.dart.intertwined.expect
@@ -90,6 +90,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -186,6 +187,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
index cde829e..eff668e 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_return_type.dart.intertwined.expect
@@ -90,6 +90,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -188,6 +189,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
index 7233bf3..b32f3d4 100644
--- a/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/constructor_recovery_set.dart.intertwined.expect
@@ -89,6 +89,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
@@ -187,6 +188,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(initializer, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
index cdf3a58..08ae948 100644
--- a/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/empty_await_for.dart.intertwined.expect
@@ -40,6 +40,7 @@
                       parseUnaryExpression((, true)
                         parsePrimary((, expression)
                           parseSend((, expression)
+                            isNextIdentifier(()
                             ensureIdentifier((, expression)
                               reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                 listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -62,6 +63,7 @@
                         parseUnaryExpression(in, true)
                           parsePrimary(in, expression)
                             parseSend(in, expression)
+                              isNextIdentifier(in)
                               ensureIdentifier(in, expression)
                                 reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
diff --git a/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
index 5b5f651..fb9fb95 100644
--- a/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/empty_for.dart.intertwined.expect
@@ -40,6 +40,7 @@
                       parseUnaryExpression((, true)
                         parsePrimary((, expression)
                           parseSend((, expression)
+                            isNextIdentifier(()
                             ensureIdentifier((, expression)
                               reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                 listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -62,6 +63,7 @@
                           parseUnaryExpression(;, true)
                             parsePrimary(;, expression)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                     listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
diff --git a/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
index a363712..c21fea8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/for_in_with_colon.dart.intertwined.expect
@@ -103,6 +103,7 @@
                                         parseSendOrFunctionLiteral({, expression)
                                           looksLikeFunctionBody(;)
                                           parseSend({, expression)
+                                            isNextIdentifier({)
                                             ensureIdentifier({, expression)
                                               listener: handleIdentifier(print, expression)
                                             listener: handleNoTypeArguments(()
@@ -116,6 +117,7 @@
                                                         parsePrimary((, expression)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
+                                                              isNextIdentifier(()
                                                               ensureIdentifier((, expression)
                                                                 listener: handleIdentifier(i, expression)
                                                               listener: handleNoTypeArguments())
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_22313.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_22313.dart.intertwined.expect
index f7a6a40..6686db3 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_22313.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_22313.dart.intertwined.expect
@@ -73,15 +73,16 @@
         parseClass(Foo, class, class, Foo)
           parseClassHeaderOpt(Foo, class, class)
             parseClassExtendsOpt(Foo)
-              listener: handleIdentifier(A, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(A, null)
-              reportRecoverableError(,, MultipleExtends)
-                listener: handleRecoverableError(MultipleExtends, ,, ,)
-              listener: handleIdentifier(B, typeReference)
-              listener: handleNoTypeArguments({)
-              listener: handleType(B, null)
-              listener: handleClassExtends(extends, 2)
+              parseClassExtendsSeenExtendsClause(extends, Foo)
+                listener: handleIdentifier(A, typeReference)
+                listener: handleNoTypeArguments(,)
+                listener: handleType(A, null)
+                reportRecoverableError(,, MultipleExtends)
+                  listener: handleRecoverableError(MultipleExtends, ,, ,)
+                listener: handleIdentifier(B, typeReference)
+                listener: handleNoTypeArguments({)
+                listener: handleType(B, null)
+                listener: handleClassExtends(extends, 2)
             parseWithClauseOpt(B)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(B)
@@ -155,15 +156,16 @@
             skipUnexpectedTokenOpt(Bar, [extends, with, implements, {])
             reportRecoverableError(extend, Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}])
               listener: handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], extend, extend)
-            listener: handleIdentifier(A, typeReference)
-            listener: handleNoTypeArguments(,)
-            listener: handleType(A, null)
-            reportRecoverableError(,, MultipleExtends)
-              listener: handleRecoverableError(MultipleExtends, ,, ,)
-            listener: handleIdentifier(B, typeReference)
-            listener: handleNoTypeArguments({)
-            listener: handleType(B, null)
-            listener: handleClassExtends(extend, 2)
+            parseClassExtendsSeenExtendsClause(extend, Bar)
+              listener: handleIdentifier(A, typeReference)
+              listener: handleNoTypeArguments(,)
+              listener: handleType(A, null)
+              reportRecoverableError(,, MultipleExtends)
+                listener: handleRecoverableError(MultipleExtends, ,, ,)
+              listener: handleIdentifier(B, typeReference)
+              listener: handleNoTypeArguments({)
+              listener: handleType(B, null)
+              listener: handleClassExtends(extend, 2)
             parseWithClauseOpt(B)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(B)
@@ -238,15 +240,16 @@
             skipUnexpectedTokenOpt(Baz, [extends, with, implements, {])
             reportRecoverableError(on, Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}])
               listener: handleRecoverableError(Message[ExpectedInstead, Expected 'extends' instead of this., null, {string: extends}], on, on)
-            listener: handleIdentifier(A, typeReference)
-            listener: handleNoTypeArguments(,)
-            listener: handleType(A, null)
-            reportRecoverableError(,, MultipleExtends)
-              listener: handleRecoverableError(MultipleExtends, ,, ,)
-            listener: handleIdentifier(B, typeReference)
-            listener: handleNoTypeArguments({)
-            listener: handleType(B, null)
-            listener: handleClassExtends(on, 2)
+            parseClassExtendsSeenExtendsClause(on, Baz)
+              listener: handleIdentifier(A, typeReference)
+              listener: handleNoTypeArguments(,)
+              listener: handleType(A, null)
+              reportRecoverableError(,, MultipleExtends)
+                listener: handleRecoverableError(MultipleExtends, ,, ,)
+              listener: handleIdentifier(B, typeReference)
+              listener: handleNoTypeArguments({)
+              listener: handleType(B, null)
+              listener: handleClassExtends(on, 2)
             parseWithClauseOpt(B)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(B)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
index 14fe0c9..9dfd6b8 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_22314.dart.intertwined.expect
@@ -201,6 +201,7 @@
                         parseUnaryExpression(=>, true)
                           parsePrimary(=>, expression)
                             parseNewExpression(=>)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -208,8 +209,10 @@
                                 listener: beginConstructorReference(A)
                                 parseQualifiedRestOpt(A, constructorReferenceContinuation)
                                 listener: beginTypeArguments(<)
-                                listener: handleRecoverableError(AnnotationOnTypeArgument, @, annotation)
-                                listener: handleRecoverableError(AnnotationOnTypeArgument, @, ))
+                                reportRecoverableErrorWithEnd(@, annotation, AnnotationOnTypeArgument)
+                                  listener: handleRecoverableError(AnnotationOnTypeArgument, @, annotation)
+                                reportRecoverableErrorWithEnd(@, ), AnnotationOnTypeArgument)
+                                  listener: handleRecoverableError(AnnotationOnTypeArgument, @, ))
                                 listener: handleIdentifier(C, typeReference)
                                 listener: handleNoTypeArguments(>)
                                 listener: handleType(C, null)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
index b6c6fda..0bf333d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810.dart.intertwined.expect
@@ -59,6 +59,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -68,6 +69,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(xor)
@@ -83,6 +85,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                         reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -97,6 +100,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -142,6 +146,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -151,6 +156,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(^)
@@ -167,6 +173,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -217,6 +224,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -226,6 +234,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(xor)
@@ -241,6 +250,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                             reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -255,6 +265,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -307,6 +318,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -316,6 +328,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(^)
@@ -332,6 +345,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -385,6 +399,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -394,6 +409,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(xor)
@@ -411,6 +427,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                           parsePrecedenceExpression(+, 14, true)
@@ -429,6 +446,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -487,6 +505,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -496,6 +515,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(^)
@@ -513,6 +533,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -576,6 +597,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -585,6 +607,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(xor)
@@ -602,6 +625,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                               parsePrecedenceExpression(+, 14, true)
@@ -620,6 +644,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -685,6 +710,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -694,6 +720,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(^)
@@ -711,6 +738,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -792,6 +820,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(xor)
@@ -804,6 +833,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                   parseArgumentsOpt(y)
                         reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -815,6 +845,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -886,6 +917,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(^)
@@ -898,6 +930,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -974,6 +1007,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(xor)
@@ -986,6 +1020,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                       parseArgumentsOpt(y)
                             reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -997,6 +1032,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1075,6 +1111,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(^)
@@ -1087,6 +1124,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1178,6 +1216,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(xor)
@@ -1190,6 +1229,7 @@
                                       parsePrimary(^, expression)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
+                                            isNextIdentifier(^)
                                             ensureIdentifier(^, expression)
                                             parseArgumentsOpt(y)
                                   reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -1201,6 +1241,7 @@
                                       parsePrimary(^, expression)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
+                                            isNextIdentifier(^)
                                             ensureIdentifier(^, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1223,6 +1264,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1313,6 +1355,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(^)
@@ -1325,6 +1368,7 @@
                                       parsePrimary(^, expression)
                                         parseSendOrFunctionLiteral(^, expression)
                                           parseSend(^, expression)
+                                            isNextIdentifier(^)
                                             ensureIdentifier(^, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1347,6 +1391,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1425,6 +1470,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(xor)
@@ -1439,6 +1485,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                   parseArgumentsOpt(y)
                           parsePrecedenceExpression(+, 14, true)
@@ -1454,6 +1501,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1538,6 +1586,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(^)
@@ -1551,6 +1600,7 @@
                             parsePrimary(^, expression)
                               parseSendOrFunctionLiteral(^, expression)
                                 parseSend(^, expression)
+                                  isNextIdentifier(^)
                                   ensureIdentifier(^, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1640,6 +1690,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(xor)
@@ -1654,6 +1705,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                       parseArgumentsOpt(y)
                               parsePrecedenceExpression(+, 14, true)
@@ -1669,6 +1721,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1760,6 +1813,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(^)
@@ -1773,6 +1827,7 @@
                                 parsePrimary(^, expression)
                                   parseSendOrFunctionLiteral(^, expression)
                                     parseSend(^, expression)
+                                      isNextIdentifier(^)
                                       ensureIdentifier(^, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1859,6 +1914,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1872,6 +1928,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(xor)
@@ -1884,6 +1941,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -1895,6 +1953,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1908,6 +1967,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(xor)
@@ -1920,6 +1980,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -1931,6 +1992,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -1955,6 +2017,7 @@
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1968,6 +2031,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(^)
@@ -1980,6 +2044,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1993,6 +2058,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(^)
@@ -2005,6 +2071,7 @@
                                                     parsePrimary(^, expression)
                                                       parseSendOrFunctionLiteral(^, expression)
                                                         parseSend(^, expression)
+                                                          isNextIdentifier(^)
                                                           ensureIdentifier(^, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -2076,6 +2143,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2087,6 +2155,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(xor)
@@ -2099,6 +2168,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -2110,6 +2180,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2128,6 +2199,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2139,6 +2211,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(xor)
@@ -2151,6 +2224,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -2162,6 +2236,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2191,6 +2266,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2211,6 +2287,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(xor)
@@ -2223,6 +2300,7 @@
                                                                 parsePrimary(^, expression)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
+                                                                      isNextIdentifier(^)
                                                                       ensureIdentifier(^, expression)
                                                                       parseArgumentsOpt(y)
                                                             reportRecoverableError(xor, Message[BinaryOperatorWrittenOut, Binary operator 'xor' is written as '^' instead of the written out word., Try replacing 'xor' with '^'., {string: xor, string2: ^}])
@@ -2234,6 +2312,7 @@
                                                                 parsePrimary(^, expression)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
+                                                                      isNextIdentifier(^)
                                                                       ensureIdentifier(^, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2309,6 +2388,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2320,6 +2400,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(^)
@@ -2332,6 +2413,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2350,6 +2432,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2361,6 +2444,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(^)
@@ -2373,6 +2457,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2402,6 +2487,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2422,6 +2508,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(^)
@@ -2434,6 +2521,7 @@
                                                                 parsePrimary(^, expression)
                                                                   parseSendOrFunctionLiteral(^, expression)
                                                                     parseSend(^, expression)
+                                                                      isNextIdentifier(^)
                                                                       ensureIdentifier(^, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2541,6 +2629,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -2561,6 +2650,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(^)
@@ -2573,6 +2663,7 @@
                                   parsePrimary(^, expression)
                                     parseSendOrFunctionLiteral(^, expression)
                                       parseSend(^, expression)
+                                        isNextIdentifier(^)
                                         ensureIdentifier(^, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
index ddb9ae4..e6dd152 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_and.dart.intertwined.expect
@@ -59,6 +59,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -68,6 +69,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(and)
@@ -83,6 +85,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -97,6 +100,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -142,6 +146,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -151,6 +156,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(&)
@@ -167,6 +173,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -217,6 +224,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -226,6 +234,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(and)
@@ -241,6 +250,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                             reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -255,6 +265,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -307,6 +318,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -316,6 +328,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(&)
@@ -332,6 +345,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -385,6 +399,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -394,6 +409,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(and)
@@ -412,6 +428,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                           parsePrecedenceExpression(+, 14, true)
@@ -430,6 +447,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -488,6 +506,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -497,6 +516,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(&)
@@ -514,6 +534,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -577,6 +598,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -586,6 +608,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(and)
@@ -604,6 +627,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                               parsePrecedenceExpression(+, 14, true)
@@ -622,6 +646,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -687,6 +712,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -696,6 +722,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(&)
@@ -713,6 +740,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -794,6 +822,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(and)
@@ -806,6 +835,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                   parseArgumentsOpt(y)
                         reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -817,6 +847,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -888,6 +919,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(&)
@@ -900,6 +932,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -976,6 +1009,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(and)
@@ -988,6 +1022,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                       parseArgumentsOpt(y)
                             reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -999,6 +1034,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1077,6 +1113,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(&)
@@ -1089,6 +1126,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1180,6 +1218,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(and)
@@ -1192,6 +1231,7 @@
                                       parsePrimary(&, expression)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
+                                            isNextIdentifier(&)
                                             ensureIdentifier(&, expression)
                                             parseArgumentsOpt(y)
                                   reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -1203,6 +1243,7 @@
                                       parsePrimary(&, expression)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
+                                            isNextIdentifier(&)
                                             ensureIdentifier(&, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1225,6 +1266,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1315,6 +1357,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(&)
@@ -1327,6 +1370,7 @@
                                       parsePrimary(&, expression)
                                         parseSendOrFunctionLiteral(&, expression)
                                           parseSend(&, expression)
+                                            isNextIdentifier(&)
                                             ensureIdentifier(&, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1349,6 +1393,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1427,6 +1472,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(and)
@@ -1442,6 +1488,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                   parseArgumentsOpt(y)
                           parsePrecedenceExpression(+, 14, true)
@@ -1457,6 +1504,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1541,6 +1589,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(&)
@@ -1554,6 +1603,7 @@
                             parsePrimary(&, expression)
                               parseSendOrFunctionLiteral(&, expression)
                                 parseSend(&, expression)
+                                  isNextIdentifier(&)
                                   ensureIdentifier(&, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1643,6 +1693,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(and)
@@ -1658,6 +1709,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                       parseArgumentsOpt(y)
                               parsePrecedenceExpression(+, 14, true)
@@ -1673,6 +1725,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1764,6 +1817,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(&)
@@ -1777,6 +1831,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1863,6 +1918,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1876,6 +1932,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(and)
@@ -1888,6 +1945,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -1899,6 +1957,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1912,6 +1971,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(and)
@@ -1924,6 +1984,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -1935,6 +1996,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -1959,6 +2021,7 @@
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1972,6 +2035,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(&)
@@ -1984,6 +2048,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1997,6 +2062,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(&)
@@ -2009,6 +2075,7 @@
                                                     parsePrimary(&, expression)
                                                       parseSendOrFunctionLiteral(&, expression)
                                                         parseSend(&, expression)
+                                                          isNextIdentifier(&)
                                                           ensureIdentifier(&, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -2080,6 +2147,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2091,6 +2159,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(and)
@@ -2103,6 +2172,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -2114,6 +2184,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2132,6 +2203,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2143,6 +2215,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(and)
@@ -2155,6 +2228,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -2166,6 +2240,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2195,6 +2270,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2215,6 +2291,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(and)
@@ -2227,6 +2304,7 @@
                                                                 parsePrimary(&, expression)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
+                                                                      isNextIdentifier(&)
                                                                       ensureIdentifier(&, expression)
                                                                       parseArgumentsOpt(y)
                                                             reportRecoverableError(and, Message[BinaryOperatorWrittenOut, Binary operator 'and' is written as '&' instead of the written out word., Try replacing 'and' with '&'., {string: and, string2: &}])
@@ -2238,6 +2316,7 @@
                                                                 parsePrimary(&, expression)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
+                                                                      isNextIdentifier(&)
                                                                       ensureIdentifier(&, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2313,6 +2392,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2324,6 +2404,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(&)
@@ -2336,6 +2417,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2354,6 +2436,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2365,6 +2448,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(&)
@@ -2377,6 +2461,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2406,6 +2491,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2426,6 +2512,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(&)
@@ -2438,6 +2525,7 @@
                                                                 parsePrimary(&, expression)
                                                                   parseSendOrFunctionLiteral(&, expression)
                                                                     parseSend(&, expression)
+                                                                      isNextIdentifier(&)
                                                                       ensureIdentifier(&, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2545,6 +2633,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -2565,6 +2654,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(&)
@@ -2577,6 +2667,7 @@
                                   parsePrimary(&, expression)
                                     parseSendOrFunctionLiteral(&, expression)
                                       parseSend(&, expression)
+                                        isNextIdentifier(&)
                                         ensureIdentifier(&, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
index 38f516b..af1484e 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_26810_or.dart.intertwined.expect
@@ -59,6 +59,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -68,6 +69,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(or)
@@ -83,6 +85,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -97,6 +100,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -142,6 +146,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(runtimeType, expression)
                                 listener: handleNoTypeArguments(.)
@@ -151,6 +156,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(hashCode, expressionContinuation)
                               listener: handleNoTypeArguments(|)
@@ -167,6 +173,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(;)
@@ -217,6 +224,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -226,6 +234,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(or)
@@ -241,6 +250,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                             reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -255,6 +265,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -307,6 +318,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(runtimeType, expression)
                                     listener: handleNoTypeArguments(.)
@@ -316,6 +328,7 @@
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(hashCode, expressionContinuation)
                                   listener: handleNoTypeArguments(|)
@@ -332,6 +345,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(;)
@@ -385,6 +399,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -394,6 +409,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(or)
@@ -412,6 +428,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                 parseArgumentsOpt(hashCode)
                           parsePrecedenceExpression(+, 14, true)
@@ -430,6 +447,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -488,6 +506,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(runtimeType, expression)
                                   listener: handleNoTypeArguments(.)
@@ -497,6 +516,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(|)
@@ -514,6 +534,7 @@
                           parsePrimary(., expressionContinuation)
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   listener: handleIdentifier(hashCode, expressionContinuation)
                                 listener: handleNoTypeArguments(+)
@@ -577,6 +598,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -586,6 +608,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(or)
@@ -604,6 +627,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                     parseArgumentsOpt(hashCode)
                               parsePrecedenceExpression(+, 14, true)
@@ -622,6 +646,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -687,6 +712,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(runtimeType, expression)
                                       listener: handleNoTypeArguments(.)
@@ -696,6 +722,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(|)
@@ -713,6 +740,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(hashCode, expressionContinuation)
                                     listener: handleNoTypeArguments(+)
@@ -794,6 +822,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(or)
@@ -806,6 +835,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                   parseArgumentsOpt(y)
                         reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -817,6 +847,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -888,6 +919,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(|)
@@ -900,6 +932,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(;)
@@ -976,6 +1009,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(or)
@@ -988,6 +1022,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                       parseArgumentsOpt(y)
                             reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -999,6 +1034,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1077,6 +1113,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(|)
@@ -1089,6 +1126,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -1180,6 +1218,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(or)
@@ -1192,6 +1231,7 @@
                                       parsePrimary(|, expression)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
+                                            isNextIdentifier(|)
                                             ensureIdentifier(|, expression)
                                             parseArgumentsOpt(y)
                                   reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -1203,6 +1243,7 @@
                                       parsePrimary(|, expression)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
+                                            isNextIdentifier(|)
                                             ensureIdentifier(|, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1225,6 +1266,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1315,6 +1357,7 @@
                                     parsePrimary(=, expression)
                                       parseSendOrFunctionLiteral(=, expression)
                                         parseSend(=, expression)
+                                          isNextIdentifier(=)
                                           ensureIdentifier(=, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(|)
@@ -1327,6 +1370,7 @@
                                       parsePrimary(|, expression)
                                         parseSendOrFunctionLiteral(|, expression)
                                           parseSend(|, expression)
+                                            isNextIdentifier(|)
                                             ensureIdentifier(|, expression)
                                               listener: handleIdentifier(y, expression)
                                             listener: handleNoTypeArguments(;)
@@ -1349,6 +1393,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(z, expression)
                                     listener: handleNoTypeArguments(;)
@@ -1427,6 +1472,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(or)
@@ -1442,6 +1488,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                   parseArgumentsOpt(y)
                           parsePrecedenceExpression(+, 14, true)
@@ -1457,6 +1504,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1541,6 +1589,7 @@
                             parsePrimary(+, expression)
                               parseSendOrFunctionLiteral(+, expression)
                                 parseSend(+, expression)
+                                  isNextIdentifier(+)
                                   ensureIdentifier(+, expression)
                                     listener: handleIdentifier(x, expression)
                                   listener: handleNoTypeArguments(|)
@@ -1554,6 +1603,7 @@
                             parsePrimary(|, expression)
                               parseSendOrFunctionLiteral(|, expression)
                                 parseSend(|, expression)
+                                  isNextIdentifier(|)
                                   ensureIdentifier(|, expression)
                                     listener: handleIdentifier(y, expression)
                                   listener: handleNoTypeArguments(+)
@@ -1643,6 +1693,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(or)
@@ -1658,6 +1709,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                       parseArgumentsOpt(y)
                               parsePrecedenceExpression(+, 14, true)
@@ -1673,6 +1725,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1764,6 +1817,7 @@
                                 parsePrimary(+, expression)
                                   parseSendOrFunctionLiteral(+, expression)
                                     parseSend(+, expression)
+                                      isNextIdentifier(+)
                                       ensureIdentifier(+, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(|)
@@ -1777,6 +1831,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(+)
@@ -1863,6 +1918,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1876,6 +1932,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(or)
@@ -1888,6 +1945,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -1899,6 +1957,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1912,6 +1971,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(or)
@@ -1924,6 +1984,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                           parseArgumentsOpt(y)
                                                 reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -1935,6 +1996,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -1959,6 +2021,7 @@
                                   parseSendOrFunctionLiteral(;, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(s, expression)
                                       listener: handleNoTypeArguments(()
@@ -1972,6 +2035,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(|)
@@ -1984,6 +2048,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments(,)
@@ -1997,6 +2062,7 @@
                                                   parsePrimary(,, expression)
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(|)
@@ -2009,6 +2075,7 @@
                                                     parsePrimary(|, expression)
                                                       parseSendOrFunctionLiteral(|, expression)
                                                         parseSend(|, expression)
+                                                          isNextIdentifier(|)
                                                           ensureIdentifier(|, expression)
                                                             listener: handleIdentifier(y, expression)
                                                           listener: handleNoTypeArguments())
@@ -2080,6 +2147,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2091,6 +2159,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(or)
@@ -2103,6 +2172,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -2114,6 +2184,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2132,6 +2203,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2143,6 +2215,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(or)
@@ -2155,6 +2228,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                         parseArgumentsOpt(y)
                               reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -2166,6 +2240,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2195,6 +2270,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2215,6 +2291,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(or)
@@ -2227,6 +2304,7 @@
                                                                 parsePrimary(|, expression)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
+                                                                      isNextIdentifier(|)
                                                                       ensureIdentifier(|, expression)
                                                                       parseArgumentsOpt(y)
                                                             reportRecoverableError(or, Message[BinaryOperatorWrittenOut, Binary operator 'or' is written as '|' instead of the written out word., Try replacing 'or' with '|'., {string: or, string2: |}])
@@ -2238,6 +2316,7 @@
                                                                 parsePrimary(|, expression)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
+                                                                      isNextIdentifier(|)
                                                                       ensureIdentifier(|, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2313,6 +2392,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2324,6 +2404,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(|)
@@ -2336,6 +2417,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(,)
@@ -2354,6 +2436,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(=)
@@ -2365,6 +2448,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(|)
@@ -2377,6 +2461,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments({)
@@ -2406,6 +2491,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -2426,6 +2512,7 @@
                                                               parsePrimary(${, expression)
                                                                 parseSendOrFunctionLiteral(${, expression)
                                                                   parseSend(${, expression)
+                                                                    isNextIdentifier(${)
                                                                     ensureIdentifier(${, expression)
                                                                       listener: handleIdentifier(x, expression)
                                                                     listener: handleNoTypeArguments(|)
@@ -2438,6 +2525,7 @@
                                                                 parsePrimary(|, expression)
                                                                   parseSendOrFunctionLiteral(|, expression)
                                                                     parseSend(|, expression)
+                                                                      isNextIdentifier(|)
                                                                       ensureIdentifier(|, expression)
                                                                         listener: handleIdentifier(y, expression)
                                                                       listener: handleNoTypeArguments(})
@@ -2545,6 +2633,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(y, expression)
                                       listener: handleNoTypeArguments(;)
@@ -2565,6 +2654,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(|)
@@ -2577,6 +2667,7 @@
                                   parsePrimary(|, expression)
                                     parseSendOrFunctionLiteral(|, expression)
                                       parseSend(|, expression)
+                                        isNextIdentifier(|)
                                         ensureIdentifier(|, expression)
                                           listener: handleIdentifier(y, expression)
                                         listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
index 117af04..6f0eacd 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_38415.crash_dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(})
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(m, expression)
                               listener: handleNoTypeArguments(()
@@ -52,6 +53,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(T, expression)
                                                 listener: handleNoTypeArguments(<)
@@ -65,6 +67,7 @@
                                               parseSendOrFunctionLiteral(<, expression)
                                                 looksLikeFunctionBody(>)
                                                 parseSend(<, expression)
+                                                  isNextIdentifier(<)
                                                   ensureIdentifier(<, expression)
                                                     listener: handleIdentifier(R, expression)
                                                   listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
index 9d7c575..f2fb1b9 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_39202.crash_dart.intertwined.expect
@@ -55,6 +55,7 @@
                   parsePrimary(=>, expression)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
+                        isNextIdentifier(=>)
                         ensureIdentifier(=>, expression)
                           listener: handleIdentifier(a, expression)
                         listener: handleNoTypeArguments(b)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.intertwined.expect
index 6f4bbfe9..9ea2f50 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_41265.crash_dart.intertwined.expect
@@ -85,10 +85,11 @@
         parseClass(DND1, class, class, DND1)
           parseClassHeaderOpt(DND1, class, class)
             parseClassExtendsOpt(DND1)
-              listener: handleIdentifier(Object, typeReference)
-              listener: handleNoTypeArguments(with)
-              listener: handleType(Object, null)
-              listener: handleClassExtends(extends, 1)
+              parseClassExtendsSeenExtendsClause(extends, DND1)
+                listener: handleIdentifier(Object, typeReference)
+                listener: handleNoTypeArguments(with)
+                listener: handleType(Object, null)
+                listener: handleClassExtends(extends, 1)
             parseWithClauseOpt(Object)
               parseTypeList(with)
                 listener: beginTypeList(M)
@@ -115,6 +116,7 @@
           parseClassHeaderRecovery(DND1, class, class)
             parseClassHeaderOpt(DND1, class, class)
               parseClassExtendsOpt(DND1)
+                parseClassExtendsSeenExtendsClause(extends, DND1)
               parseWithClauseOpt(Object)
                 parseTypeList(with)
                   ensureIdentifier(with, typeReference)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
index 988b4a5..ad14111 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_42267.dart.intertwined.expect
@@ -37,6 +37,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(builder, expression)
                               listener: handleNoTypeArguments(..)
@@ -46,6 +47,7 @@
                       parseCascadeExpression(builder)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(foo, expressionContinuation)
                           listener: handleNoTypeArguments([)
@@ -60,6 +62,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(bar, expression)
                                       listener: handleNoTypeArguments(])
@@ -84,6 +87,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(FilterSet, expression)
                               listener: handleNoTypeArguments(()
@@ -125,6 +129,7 @@
                                                             parsePrimary(=>, expression)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
+                                                                  isNextIdentifier(=>)
                                                                   ensureIdentifier(=>, expression)
                                                                     listener: handleIdentifier(builder, expression)
                                                                   listener: handleNoTypeArguments(..)
@@ -134,6 +139,7 @@
                                                           parseCascadeExpression(builder)
                                                             listener: beginCascade(..)
                                                             parseSend(.., expressionContinuation)
+                                                              isNextIdentifier(..)
                                                               ensureIdentifier(.., expressionContinuation)
                                                                 listener: handleIdentifier(foo, expressionContinuation)
                                                               listener: handleNoTypeArguments([)
@@ -148,6 +154,7 @@
                                                                     parsePrimary([, expression)
                                                                       parseSendOrFunctionLiteral([, expression)
                                                                         parseSend([, expression)
+                                                                          isNextIdentifier([)
                                                                           ensureIdentifier([, expression)
                                                                             listener: handleIdentifier(bar, expression)
                                                                           listener: handleNoTypeArguments(])
@@ -176,6 +183,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(builder, expression)
                               listener: handleNoTypeArguments(..)
@@ -185,6 +193,7 @@
                       parseCascadeExpression(builder)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(foo, expressionContinuation)
                           listener: handleNoTypeArguments([])
@@ -201,6 +210,7 @@
                               parseUnaryExpression([, true)
                                 parsePrimary([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                         listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
@@ -228,6 +238,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(FilterSet, expression)
                               listener: handleNoTypeArguments(()
@@ -269,6 +280,7 @@
                                                             parsePrimary(=>, expression)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
+                                                                  isNextIdentifier(=>)
                                                                   ensureIdentifier(=>, expression)
                                                                     listener: handleIdentifier(builder, expression)
                                                                   listener: handleNoTypeArguments(..)
@@ -278,6 +290,7 @@
                                                           parseCascadeExpression(builder)
                                                             listener: beginCascade(..)
                                                             parseSend(.., expressionContinuation)
+                                                              isNextIdentifier(..)
                                                               ensureIdentifier(.., expressionContinuation)
                                                                 listener: handleIdentifier(foo, expressionContinuation)
                                                               listener: handleNoTypeArguments([])
@@ -294,6 +307,7 @@
                                                                   parseUnaryExpression([, true)
                                                                     parsePrimary([, expression)
                                                                       parseSend([, expression)
+                                                                        isNextIdentifier([)
                                                                         ensureIdentifier([, expression)
                                                                           reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                                                             listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
@@ -325,6 +339,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(builder, expression)
                               listener: handleNoTypeArguments(..)
@@ -334,6 +349,7 @@
                       parseCascadeExpression(builder)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(foo, expressionContinuation)
                           listener: handleNoTypeArguments([)
@@ -347,6 +363,7 @@
                               parseUnaryExpression([, true)
                                 parsePrimary([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                         listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
@@ -374,6 +391,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(FilterSet, expression)
                               listener: handleNoTypeArguments(()
@@ -415,6 +433,7 @@
                                                             parsePrimary(=>, expression)
                                                               parseSendOrFunctionLiteral(=>, expression)
                                                                 parseSend(=>, expression)
+                                                                  isNextIdentifier(=>)
                                                                   ensureIdentifier(=>, expression)
                                                                     listener: handleIdentifier(builder, expression)
                                                                   listener: handleNoTypeArguments(..)
@@ -424,6 +443,7 @@
                                                           parseCascadeExpression(builder)
                                                             listener: beginCascade(..)
                                                             parseSend(.., expressionContinuation)
+                                                              isNextIdentifier(..)
                                                               ensureIdentifier(.., expressionContinuation)
                                                                 listener: handleIdentifier(foo, expressionContinuation)
                                                               listener: handleNoTypeArguments([)
@@ -437,6 +457,7 @@
                                                                   parseUnaryExpression([, true)
                                                                     parsePrimary([, expression)
                                                                       parseSend([, expression)
+                                                                        isNextIdentifier([)
                                                                         ensureIdentifier([, expression)
                                                                           reportRecoverableErrorWithToken(], Instance of 'Template<(Token) => Message>')
                                                                             listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ']'., Try inserting an identifier before ']'., {lexeme: ]}], ], ])
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
index cc1365f..1ed1153 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785.crash_dart.intertwined.expect
@@ -63,6 +63,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -81,6 +82,7 @@
                               parsePrimary(|, expression)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
+                                    isNextIdentifier(|)
                                     ensureIdentifier(|, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -91,6 +93,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -106,6 +109,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -214,6 +218,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -232,6 +237,7 @@
                               parsePrimary(&, expression)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
+                                    isNextIdentifier(&)
                                     ensureIdentifier(&, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -242,6 +248,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -257,6 +264,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
index 778aa02..96b2596 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_1.crash_dart.intertwined.expect
@@ -63,6 +63,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -81,6 +82,7 @@
                               parsePrimary(|, expression)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
+                                    isNextIdentifier(|)
                                     ensureIdentifier(|, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -91,6 +93,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -106,6 +109,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -223,6 +227,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -241,6 +246,7 @@
                               parsePrimary(|, expression)
                                 parseSendOrFunctionLiteral(|, expression)
                                   parseSend(|, expression)
+                                    isNextIdentifier(|)
                                     ensureIdentifier(|, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -251,6 +257,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -266,6 +273,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -284,6 +292,7 @@
                                 parsePrimary(|, expression)
                                   parseSendOrFunctionLiteral(|, expression)
                                     parseSend(|, expression)
+                                      isNextIdentifier(|)
                                       ensureIdentifier(|, expression)
                                       parseArgumentsOpt(c)
                             rewriter()
@@ -296,6 +305,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                   parseArgumentsOpt(c)
                           parsePrecedenceExpression(==, 8, true)
@@ -311,6 +321,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(c, expression)
                                   listener: handleNoTypeArguments(==)
@@ -416,6 +427,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -434,6 +446,7 @@
                               parsePrimary(&, expression)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
+                                    isNextIdentifier(&)
                                     ensureIdentifier(&, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -444,6 +457,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -459,6 +473,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -576,6 +591,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -594,6 +610,7 @@
                               parsePrimary(&, expression)
                                 parseSendOrFunctionLiteral(&, expression)
                                   parseSend(&, expression)
+                                    isNextIdentifier(&)
                                     ensureIdentifier(&, expression)
                                     parseArgumentsOpt(b)
                           rewriter()
@@ -604,6 +621,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(b)
                           parsePrecedenceExpression(==, 8, true)
@@ -619,6 +637,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -637,6 +656,7 @@
                                 parsePrimary(&, expression)
                                   parseSendOrFunctionLiteral(&, expression)
                                     parseSend(&, expression)
+                                      isNextIdentifier(&)
                                       ensureIdentifier(&, expression)
                                       parseArgumentsOpt(c)
                             rewriter()
@@ -649,6 +669,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                   parseArgumentsOpt(c)
                           parsePrecedenceExpression(==, 8, true)
@@ -664,6 +685,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(c, expression)
                                   listener: handleNoTypeArguments(==)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
index 9a82acc..c5680b3 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_44785_prime_2.crash_dart.intertwined.expect
@@ -63,6 +63,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -82,6 +83,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -199,6 +201,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -218,6 +221,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -238,6 +242,7 @@
                             parsePrimary(||, expression)
                               parseSendOrFunctionLiteral(||, expression)
                                 parseSend(||, expression)
+                                  isNextIdentifier(||)
                                   ensureIdentifier(||, expression)
                                     listener: handleIdentifier(c, expression)
                                   listener: handleNoTypeArguments(==)
@@ -343,6 +348,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -362,6 +368,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -479,6 +486,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments(==)
@@ -498,6 +506,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(b, expression)
                                   listener: handleNoTypeArguments(==)
@@ -518,6 +527,7 @@
                             parsePrimary(&&, expression)
                               parseSendOrFunctionLiteral(&&, expression)
                                 parseSend(&&, expression)
+                                  isNextIdentifier(&&)
                                   ensureIdentifier(&&, expression)
                                     listener: handleIdentifier(c, expression)
                                   listener: handleNoTypeArguments(==)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
index 8e981b1..fb1a4d4 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251.dart.intertwined.expect
@@ -55,6 +55,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
                               parsePrimary(Map, expression)
@@ -150,6 +151,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
                               parsePrimary(Map, expression)
@@ -189,6 +191,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Map, expression)
                               listener: beginTypeArguments(<)
@@ -242,6 +245,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Map, expression)
                               listener: handleNoTypeArguments(()
@@ -283,6 +287,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
                               parsePrimary(Map, expression)
@@ -348,6 +353,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Map, Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A map literal can't be prefixed by 'Map'., Try removing 'Map', {string: map, lexeme: Map}], Map, Map)
                               parsePrimary(Map, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
index a073268..afe7290 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list.dart.intertwined.expect
@@ -51,6 +51,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
                               parsePrimary(List, expression)
@@ -138,6 +139,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
                               parsePrimary(List, expression)
@@ -176,6 +178,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(List, expression)
                               listener: beginTypeArguments(<)
@@ -222,6 +225,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(List, expression)
                               listener: handleNoTypeArguments(()
@@ -259,6 +263,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(List, Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A list literal can't be prefixed by 'List'., Try removing 'List', {string: list, lexeme: List}], List, List)
                               parsePrimary(List, expression)
@@ -308,6 +313,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(List, expression)
                               listener: handleNoTypeArguments([)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
index 9dd8aca..a8ab4b7 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_list_new.dart.intertwined.expect
@@ -50,7 +50,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
                             parsePrimary(List, expression)
                               parseLiteralListSetMapOrFunction(List, null)
                                 listener: beginTypeArguments(<)
@@ -94,6 +96,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -139,7 +142,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
                             parsePrimary(List, expression)
                               listener: handleNoTypeArguments([])
                               parseLiteralListSuffix(List, null)
@@ -174,6 +179,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'ComplexTypeParamOrArgInfo')
                               ensureIdentifier(new, constructorReference)
@@ -223,6 +229,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'NoTypeParamOrArg')
                               ensureIdentifier(new, constructorReference)
@@ -264,7 +271,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
                             parsePrimary(List, expression)
                               parseLiteralListSetMapOrFunction(List, null)
                                 listener: beginTypeArguments(<)
@@ -311,7 +320,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, List, Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A list literal can't be prefixed by 'new List'., Try removing 'new' and 'List', {string: list, lexeme: List}], new, List)
                             parsePrimary(List, expression)
                               listener: handleNoTypeArguments([)
                               parseLiteralListSuffix(List, null)
@@ -349,6 +360,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -397,6 +409,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
index d3039be..faa270d 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_new.dart.intertwined.expect
@@ -54,7 +54,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
                             parsePrimary(Map, expression)
                               parseLiteralListSetMapOrFunction(Map, null)
                                 listener: beginTypeArguments(<)
@@ -102,6 +104,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -151,7 +154,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
                             parsePrimary(Map, expression)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Map, null)
@@ -187,6 +192,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'ComplexTypeParamOrArgInfo')
                               ensureIdentifier(new, constructorReference)
@@ -243,6 +249,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'NoTypeParamOrArg')
                               ensureIdentifier(new, constructorReference)
@@ -288,7 +295,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
                             parsePrimary(Map, expression)
                               parseLiteralListSetMapOrFunction(Map, null)
                                 listener: beginTypeArguments(<)
@@ -351,7 +360,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Map, Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A map literal can't be prefixed by 'new Map'., Try removing 'new' and 'Map', {string: map, lexeme: Map}], new, Map)
                             parsePrimary(Map, expression)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Map, null)
@@ -402,6 +413,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -466,6 +478,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
index 9fad6f6..1d5f628 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set.dart.intertwined.expect
@@ -51,6 +51,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
                               parsePrimary(Set, expression)
@@ -132,6 +133,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
                               parsePrimary(Set, expression)
@@ -167,6 +169,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Set, expression)
                               listener: beginTypeArguments(<)
@@ -213,6 +216,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Set, expression)
                               listener: handleNoTypeArguments(()
@@ -250,6 +254,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
                               parsePrimary(Set, expression)
@@ -299,6 +304,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               reportRecoverableError(Set, Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}])
                                 listener: handleRecoverableError(Message[LiteralWithClass, A set literal can't be prefixed by 'Set'., Try removing 'Set', {string: set, lexeme: Set}], Set, Set)
                               parsePrimary(Set, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
index 49f1043..264c4d0 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45251_set_new.dart.intertwined.expect
@@ -50,7 +50,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
                             parsePrimary(Set, expression)
                               parseLiteralListSetMapOrFunction(Set, null)
                                 listener: beginTypeArguments(<)
@@ -91,6 +93,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -133,7 +136,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
                             parsePrimary(Set, expression)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Set, null)
@@ -165,6 +170,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'ComplexTypeParamOrArgInfo')
                               ensureIdentifier(new, constructorReference)
@@ -214,6 +220,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             listener: beginNewExpression(new)
                             parseConstructorReference(new, Instance of 'NoTypeParamOrArg')
                               ensureIdentifier(new, constructorReference)
@@ -255,7 +262,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
                             parsePrimary(Set, expression)
                               parseLiteralListSetMapOrFunction(Set, null)
                                 listener: beginTypeArguments(<)
@@ -302,7 +311,9 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
-                            listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
+                            isNextIdentifier(new)
+                            reportRecoverableErrorWithEnd(new, Set, Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}])
+                              listener: handleRecoverableError(Message[LiteralWithClassAndNew, A set literal can't be prefixed by 'new Set'., Try removing 'new' and 'Set', {string: set, lexeme: Set}], new, Set)
                             parsePrimary(Set, expression)
                               listener: handleNoTypeArguments({)
                               parseLiteralSetOrMapSuffix(Set, null)
@@ -340,6 +351,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
@@ -388,6 +400,7 @@
                       parseUnaryExpression(=, true)
                         parsePrimary(=, expression)
                           parseNewExpression(=)
+                            isNextIdentifier(new)
                             reportRecoverableError(new, LiteralWithNew)
                               listener: handleRecoverableError(LiteralWithNew, new, new)
                             parsePrimary(new, expression)
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
index 841133c..1dee993 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45327.crash_dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(n, expression)
                                 listener: handleNoTypeArguments(is)
@@ -59,6 +60,7 @@
                           parseUnaryExpression(||, true)
                             parsePrimary(||, expression)
                               parseSend(||, expression)
+                                isNextIdentifier(||)
                                 ensureIdentifier(||, expression)
                                   reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   rewriter()
@@ -78,6 +80,7 @@
                               parsePrimary(), expression)
                                 parseSendOrFunctionLiteral(), expression)
                                   parseSend(), expression)
+                                    isNextIdentifier())
                                     ensureIdentifier(), expression)
                                       listener: handleIdentifier(or, expression)
                                     listener: handleNoTypeArguments(})
diff --git a/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
index d794537..ae57b93 100644
--- a/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/issue_45327_prime_1.crash_dart.intertwined.expect
@@ -87,6 +87,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(key, expression)
                                         listener: handleNoTypeArguments(is)
@@ -107,6 +108,7 @@
                                   parseUnaryExpression(||, true)
                                     parsePrimary(||, expression)
                                       parseSend(||, expression)
+                                        isNextIdentifier(||)
                                         ensureIdentifier(||, expression)
                                           reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                           rewriter()
@@ -126,6 +128,7 @@
                                       parsePrimary(), expression)
                                         parseSendOrFunctionLiteral(), expression)
                                           parseSend(), expression)
+                                            isNextIdentifier())
                                             ensureIdentifier(), expression)
                                               listener: handleIdentifier(or, expression)
                                             listener: handleNoTypeArguments(})
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
index a05d812..25e2025 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_class_methods.dart.intertwined.expect
@@ -80,6 +80,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -124,6 +125,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(abstract, expression)
@@ -138,6 +140,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -221,6 +224,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -265,6 +269,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(as, expression)
@@ -279,6 +284,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -366,6 +372,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -415,6 +422,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -499,6 +507,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -543,6 +552,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(async, expression)
@@ -557,6 +567,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -640,6 +651,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -687,6 +699,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(await, expression)
@@ -701,6 +714,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -788,6 +802,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -830,6 +845,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break)
@@ -878,6 +894,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -964,6 +981,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1006,6 +1024,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
@@ -1021,6 +1040,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -1108,6 +1128,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1150,6 +1171,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
@@ -1165,6 +1187,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -1252,6 +1275,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1294,6 +1318,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
@@ -1309,6 +1334,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -1396,6 +1422,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1459,6 +1486,7 @@
                                             parsePrimary((, expression)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
+                                                  isNextIdentifier(()
                                                   ensureIdentifier((, expression)
                                                     listener: handleIdentifier(x, expression)
                                                   listener: handleNoTypeArguments(-)
@@ -1546,6 +1574,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1588,6 +1617,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue)
@@ -1636,6 +1666,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -1718,6 +1749,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1762,6 +1794,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(covariant, expression)
@@ -1776,6 +1809,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1863,6 +1897,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1905,6 +1940,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
@@ -1920,6 +1956,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -2003,6 +2040,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2047,6 +2085,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(deferred, expression)
@@ -2061,6 +2100,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2148,6 +2188,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2190,6 +2231,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do)
@@ -2231,6 +2273,7 @@
                                                         parsePrimary((, expression)
                                                           parseSendOrFunctionLiteral((, expression)
                                                             parseSend((, expression)
+                                                              isNextIdentifier(()
                                                               ensureIdentifier((, expression)
                                                                 listener: handleIdentifier(x, expression)
                                                               listener: handleNoTypeArguments(-)
@@ -2269,6 +2312,7 @@
                                 parseUnaryExpression((, true)
                                   parsePrimary((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                           listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
@@ -2343,6 +2387,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2387,6 +2432,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(dynamic, expression)
@@ -2401,6 +2447,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2488,6 +2535,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2530,6 +2578,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
@@ -2558,6 +2607,7 @@
                                   parsePrimary(;, expression)
                                     inPlainSync()
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                           listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
@@ -2595,6 +2645,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -2681,6 +2732,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2723,6 +2775,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
@@ -2738,6 +2791,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -2821,6 +2875,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2865,6 +2920,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(export, expression)
@@ -2879,6 +2935,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2966,6 +3023,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3008,6 +3066,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
@@ -3023,6 +3082,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -3106,6 +3166,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3150,6 +3211,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(extension, expression)
@@ -3164,6 +3226,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -3247,6 +3310,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3291,6 +3355,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(external, expression)
@@ -3305,6 +3370,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -3388,6 +3454,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3432,6 +3499,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(factory, expression)
@@ -3446,6 +3514,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -3533,6 +3602,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3586,6 +3656,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -3673,6 +3744,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3715,6 +3787,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final)
@@ -3767,6 +3840,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -3797,6 +3871,7 @@
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                           listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -3830,6 +3905,7 @@
                                   parsePrimary(), expression)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
+                                        isNextIdentifier())
                                         ensureIdentifier(), expression)
                                           listener: handleIdentifier(, expression)
                                         listener: handleNoTypeArguments(+)
@@ -3907,6 +3983,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -3949,6 +4026,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
@@ -3964,6 +4042,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -4051,6 +4130,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4093,6 +4173,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for)
@@ -4123,6 +4204,7 @@
                                 parsePrimary((, expression)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -4149,6 +4231,7 @@
                                   parseUnaryExpression(;, true)
                                     parsePrimary(;, expression)
                                       parseSend(;, expression)
+                                        isNextIdentifier(;)
                                         ensureIdentifier(;, expression)
                                           reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                             listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -4181,6 +4264,7 @@
                                           parsePrimary(), expression)
                                             parseSendOrFunctionLiteral(), expression)
                                               parseSend(), expression)
+                                                isNextIdentifier())
                                                 ensureIdentifier(), expression)
                                                   listener: handleIdentifier(, expression)
                                                 listener: handleNoTypeArguments(+)
@@ -4256,6 +4340,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4300,6 +4385,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(Function, expression)
@@ -4314,6 +4400,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -4398,6 +4485,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4442,6 +4530,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(get, expression)
@@ -4456,6 +4545,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -4539,6 +4629,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4583,6 +4674,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(hide, expression)
@@ -4597,6 +4689,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -4684,6 +4777,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4726,6 +4820,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if)
@@ -4754,6 +4849,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(-)
@@ -4786,6 +4882,7 @@
                                         parsePrimary(), expression)
                                           parseSendOrFunctionLiteral(), expression)
                                             parseSend(), expression)
+                                              isNextIdentifier())
                                               ensureIdentifier(), expression)
                                                 listener: handleIdentifier(, expression)
                                               listener: handleNoTypeArguments(+)
@@ -4861,6 +4958,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -4905,6 +5003,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(implements, expression)
@@ -4919,6 +5018,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -5002,6 +5102,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5046,6 +5147,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(import, expression)
@@ -5060,6 +5162,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -5147,6 +5250,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5189,6 +5293,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
@@ -5204,6 +5309,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -5287,6 +5393,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5331,6 +5438,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(inout, expression)
@@ -5345,6 +5453,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -5428,6 +5537,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5472,6 +5582,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(interface, expression)
@@ -5486,6 +5597,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -5573,6 +5685,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5615,6 +5728,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is)
@@ -5663,6 +5777,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -5745,6 +5860,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5789,6 +5905,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(late, expression)
@@ -5803,6 +5920,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -5886,6 +6004,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -5930,6 +6049,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(library, expression)
@@ -5944,6 +6064,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -6027,6 +6148,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6071,6 +6193,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(mixin, expression)
@@ -6085,6 +6208,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -6168,6 +6292,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6212,6 +6337,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(native, expression)
@@ -6226,6 +6352,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -6313,6 +6440,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6354,6 +6482,7 @@
                             parseUnaryExpression(return, true)
                               parsePrimary(return, expression)
                                 parseNewExpression(return)
+                                  isNextIdentifier(new)
                                   listener: beginNewExpression(new)
                                   parseConstructorReference(new, null)
                                     ensureIdentifier(new, constructorReference)
@@ -6376,6 +6505,7 @@
                                             parsePrimary((, expression)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
+                                                  isNextIdentifier(()
                                                   ensureIdentifier((, expression)
                                                     listener: handleIdentifier(x, expression)
                                                   listener: handleNoTypeArguments(-)
@@ -6463,6 +6593,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6516,6 +6647,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6599,6 +6731,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6643,6 +6776,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(of, expression)
@@ -6657,6 +6791,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -6740,6 +6875,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6784,6 +6920,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(on, expression)
@@ -6798,6 +6935,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -6883,6 +7021,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -6927,6 +7066,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(operator, expression)
@@ -6941,6 +7081,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7024,6 +7165,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7068,6 +7210,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(out, expression)
@@ -7082,6 +7225,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7165,6 +7309,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7209,6 +7354,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(part, expression)
@@ -7223,6 +7369,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7306,6 +7453,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7350,6 +7498,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(patch, expression)
@@ -7364,6 +7513,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7447,6 +7597,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7491,6 +7642,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(required, expression)
@@ -7505,6 +7657,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7592,6 +7745,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7634,6 +7788,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
@@ -7649,6 +7804,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -7736,6 +7892,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7790,6 +7947,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -7874,6 +8032,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -7918,6 +8077,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(set, expression)
@@ -7932,6 +8092,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -8015,6 +8176,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8059,6 +8221,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(show, expression)
@@ -8073,6 +8236,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -8156,6 +8320,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8200,6 +8365,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(source, expression)
@@ -8214,6 +8380,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -8297,6 +8464,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8341,6 +8509,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(static, expression)
@@ -8355,6 +8524,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -8442,6 +8612,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8494,6 +8665,7 @@
                                             parsePrimary((, expression)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
+                                                  isNextIdentifier(()
                                                   ensureIdentifier((, expression)
                                                     listener: handleIdentifier(x, expression)
                                                   listener: handleNoTypeArguments(-)
@@ -8581,6 +8753,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8623,6 +8796,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch)
@@ -8651,6 +8825,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(-)
@@ -8694,6 +8869,7 @@
                                   parsePrimary(}, expression)
                                     parseSendOrFunctionLiteral(}, expression)
                                       parseSend(}, expression)
+                                        isNextIdentifier(})
                                         ensureIdentifier(}, expression)
                                           listener: handleIdentifier(, expression)
                                         listener: handleNoTypeArguments(+)
@@ -8767,6 +8943,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -8811,6 +8988,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(sync, expression)
@@ -8825,6 +9003,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -8935,6 +9114,7 @@
                                     parsePrimary((, expression)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
+                                          isNextIdentifier(()
                                           ensureIdentifier((, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(==)
@@ -8987,6 +9167,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -9074,6 +9255,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9126,6 +9308,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -9214,6 +9397,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9267,6 +9451,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -9354,6 +9539,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9396,6 +9582,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., Try inserting an identifier before 'try'., {lexeme: try}], try, try)
@@ -9450,6 +9637,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments(-)
@@ -9532,6 +9720,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9576,6 +9765,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(typedef, expression)
@@ -9590,6 +9780,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -9677,6 +9868,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9719,6 +9911,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., Try inserting an identifier before 'var'., {lexeme: var}], var, var)
@@ -9771,6 +9964,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -9801,6 +9995,7 @@
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                           listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -9834,6 +10029,7 @@
                                   parsePrimary(), expression)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
+                                        isNextIdentifier())
                                         ensureIdentifier(), expression)
                                           listener: handleIdentifier(, expression)
                                         listener: handleNoTypeArguments(+)
@@ -9911,6 +10107,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -9953,6 +10150,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
                                         listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., Try inserting an identifier before 'void'., {lexeme: void}], void, void)
@@ -10006,6 +10204,7 @@
                                 parsePrimary(;, expression)
                                   parseSendOrFunctionLiteral(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -10036,6 +10235,7 @@
                                 parseUnaryExpression(;, true)
                                   parsePrimary(;, expression)
                                     parseSend(;, expression)
+                                      isNextIdentifier(;)
                                       ensureIdentifier(;, expression)
                                         reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                           listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -10069,6 +10269,7 @@
                                   parsePrimary(), expression)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
+                                        isNextIdentifier())
                                         ensureIdentifier(), expression)
                                           listener: handleIdentifier(, expression)
                                         listener: handleNoTypeArguments(+)
@@ -10146,6 +10347,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -10188,6 +10390,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., Try inserting an identifier before 'while'., {lexeme: while}], while, while)
@@ -10216,6 +10419,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(-)
@@ -10248,6 +10452,7 @@
                                         parsePrimary(), expression)
                                           parseSendOrFunctionLiteral(), expression)
                                             parseSend(), expression)
+                                              isNextIdentifier())
                                               ensureIdentifier(), expression)
                                                 listener: handleIdentifier(, expression)
                                               listener: handleNoTypeArguments(+)
@@ -10327,6 +10532,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -10369,6 +10575,7 @@
                               parsePrimary(return, expression)
                                 inPlainSync()
                                 parseSend(return, expression)
+                                  isNextIdentifier(return)
                                   ensureIdentifier(return, expression)
                                     reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
@@ -10384,6 +10591,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments(-)
@@ -10467,6 +10675,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -10511,6 +10720,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(+)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(yield, expression)
@@ -10525,6 +10735,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
diff --git a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
index 9328908..3e3f317 100644
--- a/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/keyword_named_top_level_methods.dart.intertwined.expect
@@ -52,6 +52,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -96,6 +97,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(abstract, expression)
@@ -110,6 +112,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -189,6 +192,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -233,6 +237,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(as, expression)
@@ -247,6 +252,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -330,6 +336,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -379,6 +386,7 @@
                                 parsePrimary((, expression)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -459,6 +467,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -503,6 +512,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(async, expression)
@@ -517,6 +527,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -596,6 +607,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -643,6 +655,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(await, expression)
@@ -657,6 +670,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -740,6 +754,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -782,6 +797,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'break'., Try inserting an identifier before 'break'., {lexeme: break}], break, break)
@@ -830,6 +846,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -912,6 +929,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -954,6 +972,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(case, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'case' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: case}], case, case)
@@ -969,6 +988,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -1052,6 +1072,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1094,6 +1115,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(catch, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'catch' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: catch}], catch, catch)
@@ -1109,6 +1131,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -1192,6 +1215,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1234,6 +1258,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(class, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'class' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: class}], class, class)
@@ -1249,6 +1274,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -1332,6 +1358,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1395,6 +1422,7 @@
                                     parsePrimary((, expression)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
+                                          isNextIdentifier(()
                                           ensureIdentifier((, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(-)
@@ -1478,6 +1506,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1520,6 +1549,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(continue, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'continue'., Try inserting an identifier before 'continue'., {lexeme: continue}], continue, continue)
@@ -1568,6 +1598,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -1646,6 +1677,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1690,6 +1722,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(covariant, expression)
@@ -1704,6 +1737,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1787,6 +1821,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1829,6 +1864,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(default, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'default' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: default}], default, default)
@@ -1844,6 +1880,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -1923,6 +1960,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1967,6 +2005,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(deferred, expression)
@@ -1981,6 +2020,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2064,6 +2104,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2106,6 +2147,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(do, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'do'., Try inserting an identifier before 'do'., {lexeme: do}], do, do)
@@ -2147,6 +2189,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2185,6 +2228,7 @@
                         parseUnaryExpression((, true)
                           parsePrimary((, expression)
                             parseSend((, expression)
+                              isNextIdentifier(()
                               ensureIdentifier((, expression)
                                 reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
@@ -2255,6 +2299,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2299,6 +2344,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(dynamic, expression)
@@ -2313,6 +2359,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2396,6 +2443,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2438,6 +2486,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
@@ -2466,6 +2515,7 @@
                           parsePrimary(;, expression)
                             inPlainSync()
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 reportRecoverableErrorWithToken(else, Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'else'., Try inserting an identifier before 'else'., {lexeme: else}], else, else)
@@ -2503,6 +2553,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -2585,6 +2636,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2627,6 +2679,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(enum, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'enum' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: enum}], enum, enum)
@@ -2642,6 +2695,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -2721,6 +2775,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2765,6 +2820,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(export, expression)
@@ -2779,6 +2835,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2862,6 +2919,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2904,6 +2962,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(extends, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'extends' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: extends}], extends, extends)
@@ -2919,6 +2978,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -2998,6 +3058,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3042,6 +3103,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(extension, expression)
@@ -3056,6 +3118,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -3135,6 +3198,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3179,6 +3243,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(external, expression)
@@ -3193,6 +3258,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -3272,6 +3338,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3316,6 +3383,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(factory, expression)
@@ -3330,6 +3398,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -3413,6 +3482,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3466,6 +3536,7 @@
                                 parsePrimary((, expression)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -3549,6 +3620,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3591,6 +3663,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(final, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'final'., Try inserting an identifier before 'final'., {lexeme: final}], final, final)
@@ -3643,6 +3716,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(-)
@@ -3673,6 +3747,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -3706,6 +3781,7 @@
                           parsePrimary(), expression)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
+                                isNextIdentifier())
                                 ensureIdentifier(), expression)
                                   listener: handleIdentifier(, expression)
                                 listener: handleNoTypeArguments(+)
@@ -3779,6 +3855,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3821,6 +3898,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(finally, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'finally' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: finally}], finally, finally)
@@ -3836,6 +3914,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -3919,6 +3998,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -3961,6 +4041,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(for, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'for'., Try inserting an identifier before 'for'., {lexeme: for}], for, for)
@@ -3991,6 +4072,7 @@
                         parsePrimary((, expression)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
+                              isNextIdentifier(()
                               ensureIdentifier((, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(-)
@@ -4017,6 +4099,7 @@
                           parseUnaryExpression(;, true)
                             parsePrimary(;, expression)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                     listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -4049,6 +4132,7 @@
                                   parsePrimary(), expression)
                                     parseSendOrFunctionLiteral(), expression)
                                       parseSend(), expression)
+                                        isNextIdentifier())
                                         ensureIdentifier(), expression)
                                           listener: handleIdentifier(, expression)
                                         listener: handleNoTypeArguments(+)
@@ -4120,6 +4204,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4164,6 +4249,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(Function, expression)
@@ -4178,6 +4264,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -4257,6 +4344,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4301,6 +4389,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(get, expression)
@@ -4315,6 +4404,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -4394,6 +4484,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4438,6 +4529,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(hide, expression)
@@ -4452,6 +4544,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -4535,6 +4628,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4577,6 +4671,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(if, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'if'., Try inserting an identifier before 'if'., {lexeme: if}], if, if)
@@ -4605,6 +4700,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(-)
@@ -4637,6 +4733,7 @@
                                 parsePrimary(), expression)
                                   parseSendOrFunctionLiteral(), expression)
                                     parseSend(), expression)
+                                      isNextIdentifier())
                                       ensureIdentifier(), expression)
                                         listener: handleIdentifier(, expression)
                                       listener: handleNoTypeArguments(+)
@@ -4708,6 +4805,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4752,6 +4850,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(implements, expression)
@@ -4766,6 +4865,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -4845,6 +4945,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -4889,6 +4990,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(import, expression)
@@ -4903,6 +5005,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -4986,6 +5089,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5028,6 +5132,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(in, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'in' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: in}], in, in)
@@ -5043,6 +5148,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -5122,6 +5228,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5166,6 +5273,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(inout, expression)
@@ -5180,6 +5288,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -5259,6 +5368,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5303,6 +5413,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(interface, expression)
@@ -5317,6 +5428,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -5400,6 +5512,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5442,6 +5555,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(is, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is)
@@ -5490,6 +5604,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -5568,6 +5683,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5612,6 +5728,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(late, expression)
@@ -5626,6 +5743,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -5705,6 +5823,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5749,6 +5868,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(library, expression)
@@ -5763,6 +5883,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -5842,6 +5963,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -5886,6 +6008,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(mixin, expression)
@@ -5900,6 +6023,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -5979,6 +6103,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6023,6 +6148,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(native, expression)
@@ -6037,6 +6163,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6120,6 +6247,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6161,6 +6289,7 @@
                     parseUnaryExpression(return, true)
                       parsePrimary(return, expression)
                         parseNewExpression(return)
+                          isNextIdentifier(new)
                           listener: beginNewExpression(new)
                           parseConstructorReference(new, null)
                             ensureIdentifier(new, constructorReference)
@@ -6183,6 +6312,7 @@
                                     parsePrimary((, expression)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
+                                          isNextIdentifier(()
                                           ensureIdentifier((, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(-)
@@ -6266,6 +6396,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6319,6 +6450,7 @@
                                 parsePrimary((, expression)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -6398,6 +6530,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6442,6 +6575,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(of, expression)
@@ -6456,6 +6590,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6535,6 +6670,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6579,6 +6715,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(on, expression)
@@ -6593,6 +6730,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6672,6 +6810,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6716,6 +6855,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(operator, expression)
@@ -6730,6 +6870,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6809,6 +6950,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6853,6 +6995,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(out, expression)
@@ -6867,6 +7010,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -6946,6 +7090,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -6990,6 +7135,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(part, expression)
@@ -7004,6 +7150,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7083,6 +7230,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7127,6 +7275,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(patch, expression)
@@ -7141,6 +7290,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7220,6 +7370,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7264,6 +7415,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(required, expression)
@@ -7278,6 +7430,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7361,6 +7514,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7403,6 +7557,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(rethrow, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'rethrow' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: rethrow}], rethrow, rethrow)
@@ -7418,6 +7573,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -7501,6 +7657,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7555,6 +7712,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7634,6 +7792,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7678,6 +7837,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(set, expression)
@@ -7692,6 +7852,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7771,6 +7932,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7815,6 +7977,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(show, expression)
@@ -7829,6 +7992,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -7908,6 +8072,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -7952,6 +8117,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(source, expression)
@@ -7966,6 +8132,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -8045,6 +8212,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8089,6 +8257,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(static, expression)
@@ -8103,6 +8272,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -8186,6 +8356,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8238,6 +8409,7 @@
                                     parsePrimary((, expression)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
+                                          isNextIdentifier(()
                                           ensureIdentifier((, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(-)
@@ -8321,6 +8493,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8363,6 +8536,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(switch, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'switch'., Try inserting an identifier before 'switch'., {lexeme: switch}], switch, switch)
@@ -8391,6 +8565,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(-)
@@ -8434,6 +8609,7 @@
                           parsePrimary(}, expression)
                             parseSendOrFunctionLiteral(}, expression)
                               parseSend(}, expression)
+                                isNextIdentifier(})
                                 ensureIdentifier(}, expression)
                                   listener: handleIdentifier(, expression)
                                 listener: handleNoTypeArguments(+)
@@ -8503,6 +8679,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8547,6 +8724,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(sync, expression)
@@ -8561,6 +8739,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -8642,6 +8821,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8694,6 +8874,7 @@
                                     parsePrimary((, expression)
                                       parseSendOrFunctionLiteral((, expression)
                                         parseSend((, expression)
+                                          isNextIdentifier(()
                                           ensureIdentifier((, expression)
                                             listener: handleIdentifier(x, expression)
                                           listener: handleNoTypeArguments(-)
@@ -8777,6 +8958,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8829,6 +9011,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -8913,6 +9096,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -8966,6 +9150,7 @@
                                 parsePrimary((, expression)
                                   parseSendOrFunctionLiteral((, expression)
                                     parseSend((, expression)
+                                      isNextIdentifier(()
                                       ensureIdentifier((, expression)
                                         listener: handleIdentifier(x, expression)
                                       listener: handleNoTypeArguments(-)
@@ -9049,6 +9234,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -9091,6 +9277,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(try, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'try'., Try inserting an identifier before 'try'., {lexeme: try}], try, try)
@@ -9145,6 +9332,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(-)
@@ -9223,6 +9411,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -9267,6 +9456,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(typedef, expression)
@@ -9281,6 +9471,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -9364,6 +9555,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -9406,6 +9598,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(var, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'var'., Try inserting an identifier before 'var'., {lexeme: var}], var, var)
@@ -9458,6 +9651,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(-)
@@ -9488,6 +9682,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -9521,6 +9716,7 @@
                           parsePrimary(), expression)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
+                                isNextIdentifier())
                                 ensureIdentifier(), expression)
                                   listener: handleIdentifier(, expression)
                                 listener: handleNoTypeArguments(+)
@@ -9594,6 +9790,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -9636,6 +9833,7 @@
                       parsePrimary(return, expression)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               reportRecoverableErrorWithToken(void, Instance of 'Template<(Token) => Message>')
                                 listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'void'., Try inserting an identifier before 'void'., {lexeme: void}], void, void)
@@ -9689,6 +9887,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(-)
@@ -9719,6 +9918,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 reportRecoverableErrorWithToken(), Instance of 'Template<(Token) => Message>')
                                   listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ')'., Try inserting an identifier before ')'., {lexeme: )}], ), ))
@@ -9752,6 +9952,7 @@
                           parsePrimary(), expression)
                             parseSendOrFunctionLiteral(), expression)
                               parseSend(), expression)
+                                isNextIdentifier())
                                 ensureIdentifier(), expression)
                                   listener: handleIdentifier(, expression)
                                 listener: handleNoTypeArguments(+)
@@ -9825,6 +10026,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -9867,6 +10069,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(while, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'while'., Try inserting an identifier before 'while'., {lexeme: while}], while, while)
@@ -9895,6 +10098,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(-)
@@ -9927,6 +10131,7 @@
                                 parsePrimary(), expression)
                                   parseSendOrFunctionLiteral(), expression)
                                     parseSend(), expression)
+                                      isNextIdentifier())
                                       ensureIdentifier(), expression)
                                         listener: handleIdentifier(, expression)
                                       listener: handleNoTypeArguments(+)
@@ -10002,6 +10207,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -10044,6 +10250,7 @@
                       parsePrimary(return, expression)
                         inPlainSync()
                         parseSend(return, expression)
+                          isNextIdentifier(return)
                           ensureIdentifier(return, expression)
                             reportRecoverableErrorWithToken(with, Instance of 'Template<(Token) => Message>')
                               listener: handleRecoverableError(Message[ExpectedIdentifierButGotKeyword, 'with' can't be used as an identifier because it's a keyword., Try renaming this to be an identifier that isn't a keyword., {lexeme: with}], with, with)
@@ -10059,6 +10266,7 @@
                                       parsePrimary((, expression)
                                         parseSendOrFunctionLiteral((, expression)
                                           parseSend((, expression)
+                                            isNextIdentifier(()
                                             ensureIdentifier((, expression)
                                               listener: handleIdentifier(x, expression)
                                             listener: handleNoTypeArguments(-)
@@ -10138,6 +10346,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -10182,6 +10391,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(+)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(yield, expression)
@@ -10196,6 +10406,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
diff --git a/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
index 70ee37c..00a2c8c 100644
--- a/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/utf_16_le_content.crash_dart.intertwined.expect
@@ -2317,6 +2317,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(t, expression)
                               listener: handleNoTypeArguments(()
@@ -2342,6 +2343,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(H, expression)
                                                 listener: handleNoTypeArguments(e)
@@ -2358,6 +2360,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(l)
@@ -2374,6 +2377,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(l, expression)
                                                 listener: handleNoTypeArguments(l)
@@ -2390,6 +2394,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(l, expression)
                                                 listener: handleNoTypeArguments(o)
@@ -2406,6 +2411,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(o, expression)
                                                 listener: handleNoTypeArguments(,)
@@ -2418,6 +2424,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(w, expression)
                                                 listener: handleNoTypeArguments(o)
@@ -2434,6 +2441,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(o, expression)
                                                 listener: handleNoTypeArguments(r)
@@ -2450,6 +2458,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(r, expression)
                                                 listener: handleNoTypeArguments(l)
@@ -2466,6 +2475,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(l, expression)
                                                 listener: handleNoTypeArguments(d)
@@ -2482,6 +2492,7 @@
                                           parsePrimary(,, expression)
                                             parseSendOrFunctionLiteral(,, expression)
                                               parseSend(,, expression)
+                                                isNextIdentifier(,)
                                                 ensureIdentifier(,, expression)
                                                   listener: handleIdentifier(d, expression)
                                                 listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
index d4b22ff..0de9b98 100644
--- a/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/error_recovery/yield_not_in_generator.dart.intertwined.expect
@@ -37,6 +37,7 @@
                   parsePrimary(=>, expression)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
+                        isNextIdentifier(=>)
                         ensureIdentifier(=>, expression)
                           listener: handleIdentifier(Future, expression)
                         listener: handleNoTypeArguments(.)
@@ -47,6 +48,7 @@
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     looksLikeFunctionBody(;)
                     parseSend(., expressionContinuation)
+                      isNextIdentifier(.)
                       ensureIdentifier(., expressionContinuation)
                         listener: handleIdentifier(value, expressionContinuation)
                       listener: handleNoTypeArguments(()
@@ -111,6 +113,7 @@
                         parseSendOrFunctionLiteral(yield, expression)
                           looksLikeFunctionBody(;)
                           parseSend(yield, expression)
+                            isNextIdentifier(yield)
                             ensureIdentifier(yield, expression)
                               listener: handleIdentifier(f, expression)
                             listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/extensions/covariant.dart.intertwined.expect b/pkg/front_end/parser_testcases/extensions/covariant.dart.intertwined.expect
index 6bd925a..a18a857 100644
--- a/pkg/front_end/parser_testcases/extensions/covariant.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/extensions/covariant.dart.intertwined.expect
@@ -45,10 +45,11 @@
         parseClass(C, class, class, C)
           parseClassHeaderOpt(C, class, class)
             parseClassExtendsOpt(C)
-              listener: handleIdentifier(A, typeReference)
-              listener: handleNoTypeArguments({)
-              listener: handleType(A, null)
-              listener: handleClassExtends(extends, 1)
+              parseClassExtendsSeenExtendsClause(extends, C)
+                listener: handleIdentifier(A, typeReference)
+                listener: handleNoTypeArguments({)
+                listener: handleType(A, null)
+                listener: handleClassExtends(extends, 1)
             parseWithClauseOpt(A)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(A)
diff --git a/pkg/front_end/parser_testcases/extensions/not_covariant.dart.intertwined.expect b/pkg/front_end/parser_testcases/extensions/not_covariant.dart.intertwined.expect
index 79a28b8..27c8d34 100644
--- a/pkg/front_end/parser_testcases/extensions/not_covariant.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/extensions/not_covariant.dart.intertwined.expect
@@ -45,10 +45,11 @@
         parseClass(C, class, class, C)
           parseClassHeaderOpt(C, class, class)
             parseClassExtendsOpt(C)
-              listener: handleIdentifier(A, typeReference)
-              listener: handleNoTypeArguments({)
-              listener: handleType(A, null)
-              listener: handleClassExtends(extends, 1)
+              parseClassExtendsSeenExtendsClause(extends, C)
+                listener: handleIdentifier(A, typeReference)
+                listener: handleNoTypeArguments({)
+                listener: handleType(A, null)
+                listener: handleClassExtends(extends, 1)
             parseWithClauseOpt(A)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(A)
diff --git a/pkg/front_end/parser_testcases/extensions/static.dart.intertwined.expect b/pkg/front_end/parser_testcases/extensions/static.dart.intertwined.expect
index 6811d6a..2824804 100644
--- a/pkg/front_end/parser_testcases/extensions/static.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/extensions/static.dart.intertwined.expect
@@ -45,10 +45,11 @@
         parseClass(C, class, class, C)
           parseClassHeaderOpt(C, class, class)
             parseClassExtendsOpt(C)
-              listener: handleIdentifier(A, typeReference)
-              listener: handleNoTypeArguments({)
-              listener: handleType(A, null)
-              listener: handleClassExtends(extends, 1)
+              parseClassExtendsSeenExtendsClause(extends, C)
+                listener: handleIdentifier(A, typeReference)
+                listener: handleNoTypeArguments({)
+                listener: handleType(A, null)
+                listener: handleClassExtends(extends, 1)
             parseWithClauseOpt(A)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(A)
diff --git a/pkg/front_end/parser_testcases/extensions/static_covariant.dart.intertwined.expect b/pkg/front_end/parser_testcases/extensions/static_covariant.dart.intertwined.expect
index d98b093..e867360 100644
--- a/pkg/front_end/parser_testcases/extensions/static_covariant.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/extensions/static_covariant.dart.intertwined.expect
@@ -45,10 +45,11 @@
         parseClass(C, class, class, C)
           parseClassHeaderOpt(C, class, class)
             parseClassExtendsOpt(C)
-              listener: handleIdentifier(A, typeReference)
-              listener: handleNoTypeArguments({)
-              listener: handleType(A, null)
-              listener: handleClassExtends(extends, 1)
+              parseClassExtendsSeenExtendsClause(extends, C)
+                listener: handleIdentifier(A, typeReference)
+                listener: handleNoTypeArguments({)
+                listener: handleType(A, null)
+                listener: handleClassExtends(extends, 1)
             parseWithClauseOpt(A)
               listener: handleClassNoWithClause()
             parseClassOrMixinImplementsOpt(A)
diff --git a/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
index c9238c0..b75dd9a 100644
--- a/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/ambiguous_builder_01.dart.intertwined.expect
@@ -178,6 +178,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(!=)
diff --git a/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
index c3af58d..6595c40 100644
--- a/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/assignment.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
index 5c01063..af42a23 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_class_methods.dart.intertwined.expect
@@ -80,6 +80,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -124,6 +125,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(abstract, expression)
@@ -138,6 +140,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -214,6 +217,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -258,6 +262,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(as, expression)
@@ -272,6 +277,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -348,6 +354,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -392,6 +399,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(covariant, expression)
@@ -406,6 +414,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -482,6 +491,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -526,6 +536,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(deferred, expression)
@@ -540,6 +551,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -616,6 +628,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -660,6 +673,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(dynamic, expression)
@@ -674,6 +688,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -750,6 +765,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -794,6 +810,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(export, expression)
@@ -808,6 +825,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -884,6 +902,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -928,6 +947,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(external, expression)
@@ -942,6 +962,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1018,6 +1039,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1062,6 +1084,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(factory, expression)
@@ -1076,6 +1099,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1152,6 +1176,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1196,6 +1221,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(Function, expression)
@@ -1210,6 +1236,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1287,6 +1314,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1331,6 +1359,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(get, expression)
@@ -1345,6 +1374,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1421,6 +1451,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1465,6 +1496,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(implements, expression)
@@ -1479,6 +1511,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1555,6 +1588,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1599,6 +1633,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(import, expression)
@@ -1613,6 +1648,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1689,6 +1725,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1733,6 +1770,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(interface, expression)
@@ -1747,6 +1785,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1823,6 +1862,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -1867,6 +1907,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(library, expression)
@@ -1881,6 +1922,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -1959,6 +2001,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2003,6 +2046,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(operator, expression)
@@ -2017,6 +2061,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2093,6 +2138,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2137,6 +2183,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(mixin, expression)
@@ -2151,6 +2198,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2227,6 +2275,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2271,6 +2320,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(part, expression)
@@ -2285,6 +2335,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2362,6 +2413,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2406,6 +2458,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(set, expression)
@@ -2420,6 +2473,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2496,6 +2550,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2540,6 +2595,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(static, expression)
@@ -2554,6 +2610,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
@@ -2630,6 +2687,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(==)
@@ -2674,6 +2732,7 @@
                                 parseSendOrFunctionLiteral(return, expression)
                                   looksLikeFunctionBody(;)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       inPlainSync()
                                       listener: handleIdentifier(typedef, expression)
@@ -2688,6 +2747,7 @@
                                                 parsePrimary((, expression)
                                                   parseSendOrFunctionLiteral((, expression)
                                                     parseSend((, expression)
+                                                      isNextIdentifier(()
                                                       ensureIdentifier((, expression)
                                                         listener: handleIdentifier(x, expression)
                                                       listener: handleNoTypeArguments(-)
diff --git a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
index fc8f9c6..cdb944d 100644
--- a/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/built_in_identifier_top_level_methods.dart.intertwined.expect
@@ -52,6 +52,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -96,6 +97,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(abstract, expression)
@@ -110,6 +112,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -182,6 +185,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -226,6 +230,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(as, expression)
@@ -240,6 +245,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -312,6 +318,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -356,6 +363,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(covariant, expression)
@@ -370,6 +378,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -442,6 +451,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -486,6 +496,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(deferred, expression)
@@ -500,6 +511,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -572,6 +584,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -616,6 +629,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(dynamic, expression)
@@ -630,6 +644,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -702,6 +717,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -746,6 +762,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(export, expression)
@@ -760,6 +777,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -832,6 +850,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -876,6 +895,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(external, expression)
@@ -890,6 +910,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -962,6 +983,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1006,6 +1028,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(factory, expression)
@@ -1020,6 +1043,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1092,6 +1116,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1136,6 +1161,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(Function, expression)
@@ -1150,6 +1176,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1222,6 +1249,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1266,6 +1294,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(get, expression)
@@ -1280,6 +1309,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1352,6 +1382,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1396,6 +1427,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(implements, expression)
@@ -1410,6 +1442,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1482,6 +1515,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1526,6 +1560,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(import, expression)
@@ -1540,6 +1575,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1612,6 +1648,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1656,6 +1693,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(interface, expression)
@@ -1670,6 +1708,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1742,6 +1781,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1786,6 +1826,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(library, expression)
@@ -1800,6 +1841,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -1872,6 +1914,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -1916,6 +1959,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(operator, expression)
@@ -1930,6 +1974,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2002,6 +2047,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2046,6 +2092,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(mixin, expression)
@@ -2060,6 +2107,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2132,6 +2180,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2176,6 +2225,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(part, expression)
@@ -2190,6 +2240,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2262,6 +2313,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2306,6 +2358,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(set, expression)
@@ -2320,6 +2373,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2392,6 +2446,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2436,6 +2491,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(static, expression)
@@ -2450,6 +2506,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
@@ -2522,6 +2579,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(x, expression)
                                 listener: handleNoTypeArguments(==)
@@ -2566,6 +2624,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(;)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               inPlainSync()
                               listener: handleIdentifier(typedef, expression)
@@ -2580,6 +2639,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(x, expression)
                                               listener: handleNoTypeArguments(-)
diff --git a/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
index a4ee164..10d1bd2 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_01.dart.intertwined.expect
@@ -50,6 +50,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(()
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
index fe45ef1..5e65f72 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_02.dart.intertwined.expect
@@ -50,6 +50,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(<)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
index f8eda7a..a3e6477 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_03.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(.)
@@ -59,6 +60,7 @@
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(()
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
index 60cdf99..a2161dd 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_04.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(.)
@@ -59,6 +60,7 @@
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(<)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
index 715990d..0dff100 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_05.dart.intertwined.expect
@@ -59,6 +59,7 @@
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
index 79a8099..2c3bccc 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_06.dart.intertwined.expect
@@ -58,6 +58,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(.)
@@ -68,6 +69,7 @@
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             looksLikeFunctionBody())
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(f, expressionContinuation)
                                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
index b2e38f4..f30bf4b 100644
--- a/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/chained_call_07.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(.)
@@ -59,6 +60,7 @@
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           looksLikeFunctionBody(<)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: beginTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
index 7a57adc..6b2e0e1 100644
--- a/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for.dart.intertwined.expect
@@ -68,6 +68,7 @@
                             parsePrimary(;, expression)
                               parseSendOrFunctionLiteral(;, expression)
                                 parseSend(;, expression)
+                                  isNextIdentifier(;)
                                   ensureIdentifier(;, expression)
                                     listener: handleIdentifier(i, expression)
                                   listener: handleNoTypeArguments(<)
@@ -89,6 +90,7 @@
                           parsePrimary(;, expression)
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   listener: handleIdentifier(i, expression)
                                 listener: handleNoTypeArguments(++)
diff --git a/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
index a7f2679..29a07e7 100644
--- a/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for_in_no_decl.dart.intertwined.expect
@@ -60,6 +60,7 @@
                         parsePrimary((, expression)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
+                              isNextIdentifier(()
                               ensureIdentifier((, expression)
                                 listener: handleIdentifier(i, expression)
                               listener: handleNoTypeArguments(in)
diff --git a/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
index dce6b08..191bb85 100644
--- a/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/for_no_decl.dart.intertwined.expect
@@ -62,6 +62,7 @@
                         parsePrimary((, expression)
                           parseSendOrFunctionLiteral((, expression)
                             parseSend((, expression)
+                              isNextIdentifier(()
                               ensureIdentifier((, expression)
                                 listener: handleIdentifier(i, expression)
                               listener: handleNoTypeArguments(=)
@@ -85,6 +86,7 @@
                             parsePrimary(;, expression)
                               parseSendOrFunctionLiteral(;, expression)
                                 parseSend(;, expression)
+                                  isNextIdentifier(;)
                                   ensureIdentifier(;, expression)
                                     listener: handleIdentifier(i, expression)
                                   listener: handleNoTypeArguments(<)
@@ -106,6 +108,7 @@
                           parsePrimary(;, expression)
                             parseSendOrFunctionLiteral(;, expression)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   listener: handleIdentifier(i, expression)
                                 listener: handleNoTypeArguments(++)
diff --git a/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
index 1dbb08a..2b1efbc 100644
--- a/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_41121.dart.intertwined.expect
@@ -88,6 +88,7 @@
                               parsePrimary((, expression)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
+                                    isNextIdentifier(()
                                     ensureIdentifier((, expression)
                                       listener: handleIdentifier(configuration, expression)
                                     listener: handleNoTypeArguments(!=)
@@ -112,6 +113,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(=)
@@ -123,6 +125,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(configuration, expression)
                                       listener: handleNoTypeArguments({)
@@ -185,6 +188,7 @@
                               parsePrimary((, expression)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
+                                    isNextIdentifier(()
                                     ensureIdentifier((, expression)
                                       listener: handleIdentifier(configuration, expression)
                                     listener: handleNoTypeArguments(!=)
@@ -209,6 +213,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(=)
@@ -220,6 +225,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(configuration, expression)
                                       listener: handleNoTypeArguments({)
@@ -282,6 +288,7 @@
                               parsePrimary((, expression)
                                 parseSendOrFunctionLiteral((, expression)
                                   parseSend((, expression)
+                                    isNextIdentifier(()
                                     ensureIdentifier((, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(!=)
@@ -306,6 +313,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(=)
@@ -317,6 +325,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(_configuration, expression)
                                       listener: handleNoTypeArguments(.)
@@ -326,6 +335,7 @@
                               parsePrimary(., expressionContinuation)
                                 parseSendOrFunctionLiteral(., expressionContinuation)
                                   parseSend(., expressionContinuation)
+                                    isNextIdentifier(.)
                                     ensureIdentifier(., expressionContinuation)
                                       listener: handleIdentifier(foo, expressionContinuation)
                                     listener: handleNoTypeArguments({)
@@ -354,6 +364,7 @@
                               parsePrimary(return, expression)
                                 parseSendOrFunctionLiteral(return, expression)
                                   parseSend(return, expression)
+                                    isNextIdentifier(return)
                                     ensureIdentifier(return, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(;)
@@ -404,6 +415,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(=)
@@ -464,6 +476,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(_configuration, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
index 763288e..966c170 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b, expression)
                                                     listener: handleNoTypeArguments(, i=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, i=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(i, expression)
                                                     listener: handleNoTypeArguments(')
@@ -180,6 +183,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -194,6 +198,7 @@
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(<)
@@ -206,6 +211,7 @@
                                             parsePrimary(<, expression)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
+                                                  isNextIdentifier(<)
                                                   ensureIdentifier(<, expression)
                                                     listener: handleIdentifier(y, expression)
                                                   listener: handleNoTypeArguments(,)
@@ -227,6 +233,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(o, expression)
                                                                 listener: handleNoTypeArguments(as)
@@ -296,6 +303,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
index b59bb49..f5f9fc0 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_01_prime.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b, expression)
                                                     listener: handleNoTypeArguments(, i=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, i=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(i, expression)
                                                     listener: handleNoTypeArguments(')
@@ -180,6 +183,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -201,6 +205,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(x, expression)
                                                                 listener: handleNoTypeArguments(<)
@@ -213,6 +218,7 @@
                                                             parsePrimary(<, expression)
                                                               parseSendOrFunctionLiteral(<, expression)
                                                                 parseSend(<, expression)
+                                                                  isNextIdentifier(<)
                                                                   ensureIdentifier(<, expression)
                                                                     listener: handleIdentifier(y, expression)
                                                                   listener: handleNoTypeArguments())
@@ -236,6 +242,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(o, expression)
                                                                 listener: handleNoTypeArguments(as)
@@ -305,6 +312,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
index db77e3c..5d234d5 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b1=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b1, expression)
                                                     listener: handleNoTypeArguments(, b2=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, b2=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b2, expression)
                                                     listener: handleNoTypeArguments(')
@@ -180,6 +183,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -194,6 +198,7 @@
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(<)
@@ -206,6 +211,7 @@
                                             parsePrimary(<, expression)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
+                                                  isNextIdentifier(<)
                                                   ensureIdentifier(<, expression)
                                                     listener: handleIdentifier(y, expression)
                                                   listener: handleNoTypeArguments(,)
@@ -233,6 +239,7 @@
                                                             parsePrimary((, expression)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
+                                                                  isNextIdentifier(()
                                                                   ensureIdentifier((, expression)
                                                                     listener: handleIdentifier(o, expression)
                                                                   listener: handleNoTypeArguments(as)
@@ -296,6 +303,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
index 3389d26..0c2dc47 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_02_prime.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b1=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b1, expression)
                                                     listener: handleNoTypeArguments(, b2=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, b2=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b2, expression)
                                                     listener: handleNoTypeArguments(')
@@ -180,6 +183,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -201,6 +205,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(x, expression)
                                                                 listener: handleNoTypeArguments(<)
@@ -213,6 +218,7 @@
                                                             parsePrimary(<, expression)
                                                               parseSendOrFunctionLiteral(<, expression)
                                                                 parseSend(<, expression)
+                                                                  isNextIdentifier(<)
                                                                   ensureIdentifier(<, expression)
                                                                     listener: handleIdentifier(y, expression)
                                                                   listener: handleNoTypeArguments())
@@ -242,6 +248,7 @@
                                                             parsePrimary((, expression)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
+                                                                  isNextIdentifier(()
                                                                   ensureIdentifier((, expression)
                                                                     listener: handleIdentifier(o, expression)
                                                                   listener: handleNoTypeArguments(as)
@@ -305,6 +312,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
index 364051c..abf7863 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b1=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b1, expression)
                                                     listener: handleNoTypeArguments(, b2=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, b2=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b2, expression)
                                                     listener: handleNoTypeArguments(')
@@ -192,6 +195,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -206,6 +210,7 @@
                                             parseSendOrFunctionLiteral((, expression)
                                               looksLikeFunctionBody())
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(<)
@@ -218,6 +223,7 @@
                                             parsePrimary(<, expression)
                                               parseSendOrFunctionLiteral(<, expression)
                                                 parseSend(<, expression)
+                                                  isNextIdentifier(<)
                                                   ensureIdentifier(<, expression)
                                                     listener: handleIdentifier(y, expression)
                                                   listener: handleNoTypeArguments(,)
@@ -239,6 +245,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(o, expression)
                                                                 listener: handleNoTypeArguments(as)
@@ -270,6 +277,7 @@
                                                             parsePrimary((, expression)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
+                                                                  isNextIdentifier(()
                                                                   ensureIdentifier((, expression)
                                                                     listener: handleIdentifier(p, expression)
                                                                   listener: handleNoTypeArguments(as)
@@ -333,6 +341,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
index e73f340..2f77140 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_03_prime.dart.intertwined.expect
@@ -62,6 +62,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -78,6 +79,7 @@
                                                 listener: beginLiteralString('b1=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b1, expression)
                                                     listener: handleNoTypeArguments(, b2=)
@@ -89,6 +91,7 @@
                                                   listener: handleStringPart(, b2=)
                                                 parseIdentifierExpression($)
                                                   parseSend($, expression)
+                                                    isNextIdentifier($)
                                                     ensureIdentifier($, expression)
                                                       listener: handleIdentifier(b2, expression)
                                                     listener: handleNoTypeArguments(')
@@ -192,6 +195,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: handleNoTypeArguments(()
@@ -213,6 +217,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(x, expression)
                                                                 listener: handleNoTypeArguments(<)
@@ -225,6 +230,7 @@
                                                             parsePrimary(<, expression)
                                                               parseSendOrFunctionLiteral(<, expression)
                                                                 parseSend(<, expression)
+                                                                  isNextIdentifier(<)
                                                                   ensureIdentifier(<, expression)
                                                                     listener: handleIdentifier(y, expression)
                                                                   listener: handleNoTypeArguments())
@@ -248,6 +254,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(o, expression)
                                                                 listener: handleNoTypeArguments(as)
@@ -279,6 +286,7 @@
                                                             parsePrimary((, expression)
                                                               parseSendOrFunctionLiteral((, expression)
                                                                 parseSend((, expression)
+                                                                  isNextIdentifier(()
                                                                   ensureIdentifier((, expression)
                                                                     listener: handleIdentifier(p, expression)
                                                                   listener: handleNoTypeArguments(as)
@@ -342,6 +350,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(g, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
index 7711399..2611916 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_04.dart.intertwined.expect
@@ -73,6 +73,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: beginTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
index 8a8a859..8c886bc 100644
--- a/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/issue_45848_04_prime.dart.intertwined.expect
@@ -73,6 +73,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(f, expression)
                               listener: beginTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
index 8c28f4cf..f0cb42b 100644
--- a/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/missing_end_bracket.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
index 1de74c1..5479a37 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_01.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
index 555cd90..8b7f964 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_02.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
index a733856..511dc3e 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_03.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
@@ -59,6 +60,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
index ece1474..16f5ea3 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_04.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
@@ -59,6 +60,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
index 338a2bf..d52d122 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_05.dart.intertwined.expect
@@ -58,6 +58,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -110,6 +111,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
index e434bf5..0fa66b6 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_06.dart.intertwined.expect
@@ -58,6 +58,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -69,6 +70,7 @@
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             looksLikeFunctionBody())
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(f, expressionContinuation)
                                               listener: handleNoTypeArguments(()
@@ -116,6 +118,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(e, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -127,6 +130,7 @@
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             looksLikeFunctionBody(!)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(f, expressionContinuation)
                                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
index 3e1777e..83eb30d 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_07.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
@@ -59,6 +60,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
index 137c323..0c830ed 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_08.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
@@ -59,6 +60,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(f, expressionContinuation)
                             listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
index 4b44ae9..3f62960 100644
--- a/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/chained_call_with_index_01.dart.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments([)
@@ -62,6 +63,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(e, expression)
                                     listener: handleNoTypeArguments(])
@@ -83,6 +85,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(e, expression)
                                         listener: handleNoTypeArguments())
@@ -105,6 +108,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(!)
@@ -119,6 +123,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(e, expression)
                                     listener: handleNoTypeArguments(!)
@@ -142,6 +147,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(e, expression)
                                         listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
index 26b246c..dc0e5f3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(..)
@@ -58,6 +59,7 @@
                       parseCascadeExpression(x)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(f, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -71,6 +73,7 @@
                         listener: handleNonNullAssertExpression(!)
                         parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(g, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -87,6 +90,7 @@
                       parseCascadeExpression())
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(h, expressionContinuation)
                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
index f2c02d6..293d9b0 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_2.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(..)
@@ -58,6 +59,7 @@
                       parseCascadeExpression(x)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(f, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -71,6 +73,7 @@
                         listener: handleNonNullAssertExpression(!)
                         parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(g, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -98,6 +101,7 @@
                       parseCascadeExpression(!)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(h, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -111,6 +115,7 @@
                         listener: handleNonNullAssertExpression(!)
                         parseArgumentOrIndexStar(!, Instance of 'NoTypeParamOrArg', false)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(y, expressionContinuation)
                           listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
index edb5617..d743308 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_2_prime.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(..)
@@ -58,6 +59,7 @@
                       parseCascadeExpression(x)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(f, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -69,6 +71,7 @@
                           listener: handleSend(f, .)
                         listener: handleEndingBinaryExpression(..)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(g, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -94,6 +97,7 @@
                       parseCascadeExpression(])
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(h, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -105,6 +109,7 @@
                           listener: handleSend(h, .)
                         listener: handleEndingBinaryExpression(..)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(y, expressionContinuation)
                           listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
index 2bcc2ac..79c63d9 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39286_prime.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(..)
@@ -58,6 +59,7 @@
                       parseCascadeExpression(x)
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(f, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -69,6 +71,7 @@
                           listener: handleSend(f, .)
                         listener: handleEndingBinaryExpression(..)
                         parseSend(., expressionContinuation)
+                          isNextIdentifier(.)
                           ensureIdentifier(., expressionContinuation)
                             listener: handleIdentifier(g, expressionContinuation)
                           listener: handleNoTypeArguments(()
@@ -85,6 +88,7 @@
                       parseCascadeExpression())
                         listener: beginCascade(..)
                         parseSend(.., expressionContinuation)
+                          isNextIdentifier(..)
                           ensureIdentifier(.., expressionContinuation)
                             listener: handleIdentifier(h, expressionContinuation)
                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
index 07e059f..9b90848 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39326.dart.intertwined.expect
@@ -57,6 +57,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c, expression)
                               listener: handleNoTypeArguments(?.)
@@ -94,6 +95,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c, expression)
                               listener: handleNoTypeArguments(?)
@@ -143,6 +145,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c, expression)
                               listener: handleNoTypeArguments(?)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
index 2084814..01fa912 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39697.dart.intertwined.expect
@@ -30,6 +30,7 @@
                   parsePrimary(=>, expression)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
+                        isNextIdentifier(=>)
                         ensureIdentifier(=>, expression)
                           listener: handleIdentifier(Zone, expression)
                         listener: handleNoTypeArguments(.)
@@ -39,6 +40,7 @@
                 parsePrimary(., expressionContinuation)
                   parseSendOrFunctionLiteral(., expressionContinuation)
                     parseSend(., expressionContinuation)
+                      isNextIdentifier(.)
                       ensureIdentifier(., expressionContinuation)
                         listener: handleIdentifier(current, expressionContinuation)
                       listener: handleNoTypeArguments([)
@@ -53,6 +55,7 @@
                         parsePrimary([, expression)
                           parseSendOrFunctionLiteral([, expression)
                             parseSend([, expression)
+                              isNextIdentifier([)
                               ensureIdentifier([, expression)
                                 listener: handleIdentifier(logKey, expression)
                               listener: handleNoTypeArguments(])
@@ -75,6 +78,7 @@
                     parsePrimary(??, expression)
                       parseSendOrFunctionLiteral(??, expression)
                         parseSend(??, expression)
+                          isNextIdentifier(??)
                           ensureIdentifier(??, expression)
                             listener: handleIdentifier(_default, expression)
                           listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
index 3049622..fc65700 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39697_prime.dart.intertwined.expect
@@ -38,6 +38,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(Zone, expression)
                                         listener: handleNoTypeArguments(.)
@@ -47,6 +48,7 @@
                                 parsePrimary(., expressionContinuation)
                                   parseSendOrFunctionLiteral(., expressionContinuation)
                                     parseSend(., expressionContinuation)
+                                      isNextIdentifier(.)
                                       ensureIdentifier(., expressionContinuation)
                                         listener: handleIdentifier(current, expressionContinuation)
                                       listener: handleNoTypeArguments([)
@@ -61,6 +63,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(logKey, expression)
                                               listener: handleNoTypeArguments(])
@@ -85,6 +88,7 @@
                     parsePrimary(??, expression)
                       parseSendOrFunctionLiteral(??, expression)
                         parseSend(??, expression)
+                          isNextIdentifier(??)
                           ensureIdentifier(??, expression)
                             listener: handleIdentifier(_default, expression)
                           listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
index 5d6b616..37429ab 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39723.dart.intertwined.expect
@@ -70,6 +70,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(index, expression)
                                 listener: handleNoTypeArguments(;)
@@ -154,6 +155,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
@@ -165,6 +167,7 @@
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
+                            isNextIdentifier(?.)
                             ensureIdentifier(?., expressionContinuation)
                               listener: handleIdentifier(toString, expressionContinuation)
                             listener: handleNoTypeArguments(()
@@ -189,6 +192,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
@@ -221,6 +225,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
@@ -261,6 +266,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
index 50f71df..093880f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39723_prime.dart.intertwined.expect
@@ -70,6 +70,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(index, expression)
                                 listener: handleNoTypeArguments(;)
@@ -163,6 +164,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(a, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -176,6 +178,7 @@
                           parseSendOrFunctionLiteral(?., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(?., expressionContinuation)
+                              isNextIdentifier(?.)
                               ensureIdentifier(?., expressionContinuation)
                                 listener: handleIdentifier(toString, expressionContinuation)
                               listener: handleNoTypeArguments(()
@@ -209,6 +212,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(a, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -252,6 +256,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(a, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -303,6 +308,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(a, expression)
                                                 listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
index a97ee3b..6be91d6 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776.dart.intertwined.expect
@@ -144,6 +144,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                               parseArgumentsOpt(foo)
                   listener: beginMetadataStar(Function)
@@ -165,6 +166,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(;)
@@ -187,6 +189,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f1, expression)
                               listener: handleNoTypeArguments(!)
@@ -234,6 +237,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(;)
@@ -256,6 +260,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f2, expression)
                               listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
index 824c818..4309320 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime1.dart.intertwined.expect
@@ -144,6 +144,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                               parseArgumentsOpt(foo)
                   listener: beginMetadataStar(Function)
@@ -165,6 +166,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(;)
@@ -187,6 +189,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f1, expression)
                               listener: handleNoTypeArguments(!)
@@ -234,6 +237,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(;)
@@ -257,6 +261,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f2, expression)
                               listener: beginTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
index 6643b98..f44705f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime2.dart.intertwined.expect
@@ -144,6 +144,7 @@
                         parsePrimary(=, expression)
                           parseSendOrFunctionLiteral(=, expression)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                               parseArgumentsOpt(foo)
                   listener: beginMetadataStar(Function)
@@ -165,6 +166,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(foo, expression)
                                     listener: handleNoTypeArguments(;)
@@ -187,6 +189,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f1, expression)
                               listener: handleNoTypeArguments(!)
@@ -234,6 +237,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(;)
@@ -265,6 +269,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(f2, expression)
                                                 listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
index 0c1ffd1..5b8824f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime3.dart.intertwined.expect
@@ -129,6 +129,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(;)
@@ -151,6 +152,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f2, expression)
                               listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
index 357e13e..5e4d944 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_39776_prime4.dart.intertwined.expect
@@ -129,6 +129,7 @@
                               parsePrimary(=, expression)
                                 parseSendOrFunctionLiteral(=, expression)
                                   parseSend(=, expression)
+                                    isNextIdentifier(=)
                                     ensureIdentifier(=, expression)
                                       listener: handleIdentifier(bar, expression)
                                     listener: handleNoTypeArguments(;)
@@ -152,6 +153,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(f2, expression)
                               listener: beginTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
index 2e0628e..7be843b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_01.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments())
@@ -59,6 +60,7 @@
                         parsePrimary(case, expression)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
+                              isNextIdentifier(case)
                               ensureIdentifier(case, expression)
                                 listener: handleIdentifier(b, expression)
                               listener: handleNoTypeArguments(?)
@@ -77,6 +79,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(c)
                         parseExpressionWithoutCascade(:)
@@ -85,6 +88,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(d)
                       parseConditionalExpressionRest(b)
@@ -101,6 +105,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(c, expression)
                                               listener: handleNoTypeArguments(])
@@ -116,6 +121,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(d, expression)
                                     listener: handleNoTypeArguments(:)
@@ -140,6 +146,7 @@
                                   parsePrimary(:, expression)
                                     parseSendOrFunctionLiteral(:, expression)
                                       parseSend(:, expression)
+                                        isNextIdentifier(:)
                                         ensureIdentifier(:, expression)
                                           listener: handleIdentifier(e, expression)
                                         listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
index 1a79606..4d90b4e 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_02.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments())
@@ -59,6 +60,7 @@
                         parsePrimary(case, expression)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
+                              isNextIdentifier(case)
                               ensureIdentifier(case, expression)
                                 listener: handleIdentifier(b, expression)
                               listener: handleNoTypeArguments(?)
@@ -77,6 +79,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(c)
                         parseExpressionWithoutCascade(:)
@@ -95,6 +98,7 @@
                                                   parsePrimary({, expression)
                                                     inPlainSync()
                                                     parseSend({, expression)
+                                                      isNextIdentifier({)
                                                       ensureIdentifier({, expression)
                                                         reportRecoverableErrorWithToken(break, Instance of 'Template<(Token) => Message>')
                                                         rewriter()
@@ -107,6 +111,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
index be7185a..bda756d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_03.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments())
@@ -59,6 +60,7 @@
                         parsePrimary(case, expression)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
+                              isNextIdentifier(case)
                               ensureIdentifier(case, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(?)
@@ -82,6 +84,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(baz)
                       parseConditionalExpressionRest(x)
@@ -107,6 +110,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(baz, expression)
                                     listener: handleNoTypeArguments(:)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
index 3e8bb5a..9e17362 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_04.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments())
@@ -59,6 +60,7 @@
                         parsePrimary(case, expression)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
+                              isNextIdentifier(case)
                               ensureIdentifier(case, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(?)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
index a69553c..d9a4309 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_case_05.dart.intertwined.expect
@@ -39,6 +39,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(a, expression)
                                 listener: handleNoTypeArguments())
@@ -59,6 +60,7 @@
                         parsePrimary(case, expression)
                           parseSendOrFunctionLiteral(case, expression)
                             parseSend(case, expression)
+                              isNextIdentifier(case)
                               ensureIdentifier(case, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(?)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
index 433eec8..cd8f064 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional.dart.intertwined.expect
@@ -71,6 +71,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -89,6 +90,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
@@ -97,6 +99,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -113,6 +116,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -128,6 +132,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -149,6 +154,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -167,6 +173,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
@@ -175,6 +182,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -191,6 +199,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -206,6 +215,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -227,6 +237,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -245,12 +256,14 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                   parseArgumentsOpt(toString)
                                     parseArguments(toString)
@@ -261,6 +274,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -277,6 +291,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -288,6 +303,7 @@
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(toString, expressionContinuation)
                                   listener: handleNoTypeArguments(()
@@ -306,6 +322,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -327,6 +344,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -345,12 +363,14 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                   parseArgumentsOpt(toString)
                                     parseArguments(toString)
@@ -361,6 +381,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -377,6 +398,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -388,6 +410,7 @@
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(toString, expressionContinuation)
                                   listener: handleNoTypeArguments(()
@@ -406,6 +429,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -427,6 +451,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -452,6 +477,7 @@
                                           parsePrimary([, expression)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
+                                                isNextIdentifier([)
                                                 ensureIdentifier([, expression)
                                                   listener: handleIdentifier(b, expression)
                                                 listener: handleNoTypeArguments(])
@@ -478,6 +504,7 @@
                                           parsePrimary([, expression)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
+                                                isNextIdentifier([)
                                                 ensureIdentifier([, expression)
                                                   listener: handleIdentifier(c, expression)
                                                 listener: handleNoTypeArguments(])
@@ -500,6 +527,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -528,6 +556,7 @@
                                                         parsePrimary([, expression)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
+                                                              isNextIdentifier([)
                                                               ensureIdentifier([, expression)
                                                                 listener: handleIdentifier(b, expression)
                                                               listener: handleNoTypeArguments(])
@@ -559,6 +588,7 @@
                                                         parsePrimary([, expression)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
+                                                              isNextIdentifier([)
                                                               ensureIdentifier([, expression)
                                                                 listener: handleIdentifier(c, expression)
                                                               listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
index 2b95e24..6c1ac05 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_conditional_2.dart.intertwined.expect
@@ -63,6 +63,7 @@
                       parsePrimary(return, expression)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(a, expression)
                             listener: handleNoTypeArguments(?)
@@ -82,6 +83,7 @@
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                             parseArgumentsOpt(b)
                                               parseArguments(b)
@@ -114,6 +116,7 @@
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                               listener: handleIdentifier(b, expression)
                                             listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
index c170335..faba2d8 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_access.dart.intertwined.expect
@@ -64,6 +64,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?.)
@@ -79,6 +80,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(b, expression)
                                       listener: handleNoTypeArguments(])
@@ -101,6 +103,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -119,6 +122,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
@@ -128,6 +132,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(b, expression)
                                     listener: handleNoTypeArguments(])
@@ -149,6 +154,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -167,6 +173,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
@@ -176,6 +183,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(b, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
index 9a4dd5e..81546e3 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_index_set.dart.intertwined.expect
@@ -71,6 +71,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?.)
@@ -86,6 +87,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(b, expression)
                                       listener: handleNoTypeArguments(])
@@ -99,6 +101,7 @@
                           parsePrimary(=, expression)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
+                                isNextIdentifier(=)
                                 ensureIdentifier(=, expression)
                                   listener: handleIdentifier(c, expression)
                                 listener: handleNoTypeArguments(;)
@@ -120,6 +123,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -138,6 +142,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrecedenceExpression(=, 1, false)
@@ -145,6 +150,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                       parseArgumentsOpt(c)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
@@ -154,6 +160,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(b, expression)
                                     listener: handleNoTypeArguments(])
@@ -166,6 +173,7 @@
                           parsePrimary(=, expression)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
+                                isNextIdentifier(=)
                                 ensureIdentifier(=, expression)
                                   listener: handleIdentifier(c, expression)
                                 listener: handleNoTypeArguments(;)
@@ -187,6 +195,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -205,6 +214,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrecedenceExpression(=, 1, false)
@@ -212,6 +222,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                       parseArgumentsOpt(c)
                       parseArgumentOrIndexStar(a, Instance of 'NoTypeParamOrArg', true)
@@ -221,6 +232,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(b, expression)
                                     listener: handleNoTypeArguments(])
@@ -233,6 +245,7 @@
                           parsePrimary(=, expression)
                             parseSendOrFunctionLiteral(=, expression)
                               parseSend(=, expression)
+                                isNextIdentifier(=)
                                 ensureIdentifier(=, expression)
                                   listener: handleIdentifier(c, expression)
                                 listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
index 7f14904..b921880 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus.dart.intertwined.expect
@@ -50,6 +50,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
index 2f6e742..98bb429 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_lookup_plus_plus.dart.intertwined.expect
@@ -62,6 +62,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(x, expression)
                               listener: handleNoTypeArguments(?)
@@ -80,6 +81,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(i)
                       parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', true)
@@ -89,6 +91,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(i, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
index 707c726..3c3dc60 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_no_type_arguments.dart.intertwined.expect
@@ -64,6 +64,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?.)
@@ -74,6 +75,7 @@
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
+                            isNextIdentifier(?.)
                             ensureIdentifier(?., expressionContinuation)
                               listener: handleIdentifier(call, expressionContinuation)
                             listener: handleNoTypeArguments(()
@@ -87,6 +89,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments())
@@ -110,6 +113,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -132,6 +136,7 @@
                                               parsePrimary((, expression)
                                                 parseSendOrFunctionLiteral((, expression)
                                                   parseSend((, expression)
+                                                    isNextIdentifier(()
                                                     ensureIdentifier((, expression)
                                                       listener: handleIdentifier(b, expression)
                                                     listener: handleNoTypeArguments())
@@ -151,6 +156,7 @@
                             parseUnaryExpression(:, false)
                               parsePrimary(:, expression)
                                 parseSend(:, expression)
+                                  isNextIdentifier(:)
                                   ensureIdentifier(:, expression)
                                     reportRecoverableErrorWithToken(;, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got ';'., Try inserting an identifier before ';'., {lexeme: ;}], ;, ;)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
index 2079800..8a09850 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_method_call_with_type_arguments.dart.intertwined.expect
@@ -64,6 +64,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?.)
@@ -74,6 +75,7 @@
                         parseSendOrFunctionLiteral(?., expressionContinuation)
                           looksLikeFunctionBody(;)
                           parseSend(?., expressionContinuation)
+                            isNextIdentifier(?.)
                             ensureIdentifier(?., expressionContinuation)
                               listener: handleIdentifier(call, expressionContinuation)
                             listener: beginTypeArguments(<)
@@ -91,6 +93,7 @@
                                         parsePrimary((, expression)
                                           parseSendOrFunctionLiteral((, expression)
                                             parseSend((, expression)
+                                              isNextIdentifier(()
                                               ensureIdentifier((, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments())
@@ -114,6 +117,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -175,6 +179,7 @@
                             parseUnaryExpression(:, false)
                               parsePrimary(:, expression)
                                 parseSend(:, expression)
+                                  isNextIdentifier(:)
                                   ensureIdentifier(:, expression)
                                     reportRecoverableErrorWithToken(}, Instance of 'Template<(Token) => Message>')
                                       listener: handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '}'., Try inserting an identifier before '}'., {lexeme: }}], }, })
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
index 2aa0856..9b33b16 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40267_plus_plus_lookup.dart.intertwined.expect
@@ -65,6 +65,7 @@
                               parsePrimary(++, expression)
                                 parseSendOrFunctionLiteral(++, expression)
                                   parseSend(++, expression)
+                                    isNextIdentifier(++)
                                     ensureIdentifier(++, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(?)
@@ -83,6 +84,7 @@
                                               parsePrimary([, expression)
                                                 parseSendOrFunctionLiteral([, expression)
                                                   parseSend([, expression)
+                                                    isNextIdentifier([)
                                                     ensureIdentifier([, expression)
                                                     parseArgumentsOpt(i)
                             parseArgumentOrIndexStar(x, Instance of 'NoTypeParamOrArg', true)
@@ -92,6 +94,7 @@
                                     parsePrimary([, expression)
                                       parseSendOrFunctionLiteral([, expression)
                                         parseSend([, expression)
+                                          isNextIdentifier([)
                                           ensureIdentifier([, expression)
                                             listener: handleIdentifier(i, expression)
                                           listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
index 6fc667d..5d6d6b4 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793.dart.intertwined.expect
@@ -50,6 +50,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(sample, expression)
                                 listener: handleNoTypeArguments(.)
@@ -59,6 +60,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(value, expressionContinuation)
                               listener: handleNoTypeArguments(!)
@@ -95,6 +97,7 @@
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
+                                          isNextIdentifier({)
                                           ensureIdentifier({, expression)
                                             listener: handleIdentifier(print, expression)
                                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
index 484f431..fc4e1e4 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime.dart.intertwined.expect
@@ -58,6 +58,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(sample, expression)
                                                 listener: handleNoTypeArguments(.)
@@ -67,6 +68,7 @@
                                         parsePrimary(., expressionContinuation)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(value, expressionContinuation)
                                               listener: handleNoTypeArguments(!)
@@ -105,6 +107,7 @@
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
+                                          isNextIdentifier({)
                                           ensureIdentifier({, expression)
                                             listener: handleIdentifier(print, expression)
                                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
index 79a4016..8a9e55b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime2.dart.intertwined.expect
@@ -58,6 +58,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(sample, expression)
                                                 listener: handleNoTypeArguments(.)
@@ -67,6 +68,7 @@
                                         parsePrimary(., expressionContinuation)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(value, expressionContinuation)
                                               listener: handleNoTypeArguments())
@@ -104,6 +106,7 @@
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
+                                          isNextIdentifier({)
                                           ensureIdentifier({, expression)
                                             listener: handleIdentifier(print, expression)
                                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
index 7da58ec..be692e6 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime3.dart.intertwined.expect
@@ -50,6 +50,7 @@
                           parsePrimary((, expression)
                             parseSendOrFunctionLiteral((, expression)
                               parseSend((, expression)
+                                isNextIdentifier(()
                                 ensureIdentifier((, expression)
                                   listener: handleIdentifier(sample, expression)
                                 listener: handleNoTypeArguments(.)
@@ -59,6 +60,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(value, expressionContinuation)
                               listener: handleNoTypeArguments(<)
@@ -94,6 +96,7 @@
                                       parseSendOrFunctionLiteral({, expression)
                                         looksLikeFunctionBody(;)
                                         parseSend({, expression)
+                                          isNextIdentifier({)
                                           ensureIdentifier({, expression)
                                             listener: handleIdentifier(print, expression)
                                           listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
index 192785b..32789fa 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime4.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(.)
@@ -58,6 +59,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(x, expressionContinuation)
                             listener: handleNoTypeArguments(<)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
index 9bb83fa..ac8630f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40793_prime5.dart.intertwined.expect
@@ -49,6 +49,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(e, expression)
                               listener: handleNoTypeArguments(.)
@@ -58,6 +59,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(x, expressionContinuation)
                             listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
index 170bf38..4bd0d59 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_01.dart.intertwined.expect
@@ -104,6 +104,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -115,6 +116,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(as)
@@ -141,6 +143,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -211,6 +214,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -222,6 +226,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(is)
@@ -245,6 +250,7 @@
                                       parsePrimary(?, expression)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
+                                            isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
                                               listener: handleIdentifier(o, expression)
                                             listener: handleNoTypeArguments(.)
@@ -254,6 +260,7 @@
                                     parsePrimary(., expressionContinuation)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
                                           ensureIdentifier(., expressionContinuation)
                                             listener: handleIdentifier(length, expressionContinuation)
                                           listener: handleNoTypeArguments(:)
@@ -281,6 +288,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -351,6 +359,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -362,6 +371,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(is)
@@ -385,6 +395,7 @@
                                       parsePrimary(?, expression)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
+                                            isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
                                               listener: handleIdentifier(o, expression)
                                             listener: handleNoTypeArguments(.)
@@ -394,6 +405,7 @@
                                     parsePrimary(., expressionContinuation)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
                                           ensureIdentifier(., expressionContinuation)
                                             listener: handleIdentifier(length, expressionContinuation)
                                           listener: handleNoTypeArguments(:)
@@ -421,6 +433,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -491,6 +504,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -502,6 +516,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(as)
@@ -525,6 +540,7 @@
                                       parsePrimary(?, expression)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
+                                            isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
                                               listener: handleIdentifier(o, expression)
                                             listener: handleNoTypeArguments(.)
@@ -534,6 +550,7 @@
                                     parsePrimary(., expressionContinuation)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
                                           ensureIdentifier(., expressionContinuation)
                                             listener: handleIdentifier(length, expressionContinuation)
                                           listener: handleNoTypeArguments(:)
@@ -561,6 +578,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -631,6 +649,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -642,6 +661,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(as)
@@ -665,6 +685,7 @@
                                       parsePrimary(?, expression)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
+                                            isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
                                               listener: handleIdentifier(o, expression)
                                             listener: handleNoTypeArguments(.)
@@ -674,6 +695,7 @@
                                     parsePrimary(., expressionContinuation)
                                       parseSendOrFunctionLiteral(., expressionContinuation)
                                         parseSend(., expressionContinuation)
+                                          isNextIdentifier(.)
                                           ensureIdentifier(., expressionContinuation)
                                             listener: handleIdentifier(length, expressionContinuation)
                                           listener: handleNoTypeArguments(:)
@@ -701,6 +723,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
index 651f195..6678394c 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_02.dart.intertwined.expect
@@ -104,6 +104,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -115,6 +116,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(as)
@@ -141,6 +143,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
index 1246230..bfe4f7d 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_40834_03.dart.intertwined.expect
@@ -104,6 +104,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(x, expression)
                                     listener: handleNoTypeArguments(=)
@@ -115,6 +116,7 @@
                                 parsePrimary(=, expression)
                                   parseSendOrFunctionLiteral(=, expression)
                                     parseSend(=, expression)
+                                      isNextIdentifier(=)
                                       ensureIdentifier(=, expression)
                                         listener: handleIdentifier(o, expression)
                                       listener: handleNoTypeArguments(!=)
@@ -136,6 +138,7 @@
                                       parsePrimary(?, expression)
                                         parseSendOrFunctionLiteral(?, expression)
                                           parseSend(?, expression)
+                                            isNextIdentifier(?)
                                             ensureIdentifier(?, expression)
                                               listener: handleIdentifier(o, expression)
                                             listener: handleNoTypeArguments(as)
@@ -171,6 +174,7 @@
                               parsePrimary(,, expression)
                                 parseSendOrFunctionLiteral(,, expression)
                                   parseSend(,, expression)
+                                    isNextIdentifier(,)
                                     ensureIdentifier(,, expression)
                                       listener: handleIdentifier(y, expression)
                                     listener: handleNoTypeArguments(=)
@@ -245,6 +249,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(is)
@@ -305,6 +310,7 @@
                                               parseSendOrFunctionLiteral({, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend({, expression)
+                                                  isNextIdentifier({)
                                                   ensureIdentifier({, expression)
                                                     listener: handleIdentifier(print, expression)
                                                   listener: handleNoTypeArguments(()
@@ -384,6 +390,7 @@
                                   parsePrimary((, expression)
                                     parseSendOrFunctionLiteral((, expression)
                                       parseSend((, expression)
+                                        isNextIdentifier(()
                                         ensureIdentifier((, expression)
                                           listener: handleIdentifier(x, expression)
                                         listener: handleNoTypeArguments(is)
@@ -444,6 +451,7 @@
                                               parseSendOrFunctionLiteral({, expression)
                                                 looksLikeFunctionBody(;)
                                                 parseSend({, expression)
+                                                  isNextIdentifier({)
                                                   ensureIdentifier({, expression)
                                                     listener: handleIdentifier(print, expression)
                                                   listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
index b84966b..281cf5f 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_41177.dart.intertwined.expect
@@ -66,6 +66,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
@@ -95,6 +96,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -134,6 +136,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(!)
@@ -183,6 +186,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(a, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -225,6 +229,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(b, expression)
                               listener: handleNoTypeArguments(!)
@@ -295,6 +300,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(b, expression)
                                                 listener: handleNoTypeArguments(!)
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
index 80be6b7..86b9cdb 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_41597.dart.intertwined.expect
@@ -73,6 +73,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -86,6 +87,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments())
@@ -109,6 +111,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -122,6 +125,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -146,6 +150,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -161,6 +166,7 @@
                                               parsePrimary(!, expression)
                                                 parseSendOrFunctionLiteral(!, expression)
                                                   parseSend(!, expression)
+                                                    isNextIdentifier(!)
                                                     ensureIdentifier(!, expression)
                                                       listener: handleIdentifier(x, expression)
                                                     listener: handleNoTypeArguments())
diff --git a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
index b50f901..7069d7b 100644
--- a/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/issue_42621.dart.intertwined.expect
@@ -59,6 +59,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(Order, expression)
                             listener: handleNoTypeArguments(()
@@ -71,6 +72,7 @@
                     parseCascadeExpression())
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(x, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -85,6 +87,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
@@ -115,6 +118,7 @@
                     parseCascadeExpression(List)
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(y, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -129,6 +133,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
@@ -220,6 +225,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(Order, expression)
                             listener: handleNoTypeArguments(()
@@ -232,6 +238,7 @@
                     parseCascadeExpression())
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(x, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -246,6 +253,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
@@ -276,6 +284,7 @@
                     parseCascadeExpression(?)
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(y, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -290,6 +299,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
@@ -381,6 +391,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(Order, expression)
                             listener: handleNoTypeArguments(()
@@ -393,6 +404,7 @@
                     parseCascadeExpression())
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(x, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -415,6 +427,7 @@
                                             parsePrimary((, expression)
                                               parseSendOrFunctionLiteral((, expression)
                                                 parseSend((, expression)
+                                                  isNextIdentifier(()
                                                   ensureIdentifier((, expression)
                                                     listener: handleIdentifier(json, expression)
                                                   listener: handleNoTypeArguments([)
@@ -447,6 +460,7 @@
                     parseCascadeExpression())
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(y, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -461,6 +475,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
@@ -552,6 +567,7 @@
                         parseSendOrFunctionLiteral(return, expression)
                           looksLikeFunctionBody(..)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(Order, expression)
                             listener: handleNoTypeArguments(()
@@ -564,6 +580,7 @@
                     parseCascadeExpression())
                       listener: beginCascade(..)
                       parseSend(.., expressionContinuation)
+                        isNextIdentifier(..)
                         ensureIdentifier(.., expressionContinuation)
                           listener: handleIdentifier(x, expressionContinuation)
                         listener: handleNoTypeArguments(=)
@@ -578,6 +595,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(json, expression)
                                   listener: handleNoTypeArguments([)
diff --git a/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
index 36d7e57..b245255 100644
--- a/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/late_member.dart.intertwined.expect
@@ -50,6 +50,7 @@
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
                                 parseNewExpression(=)
+                                  isNextIdentifier(new)
                                   listener: beginNewExpression(new)
                                   parseConstructorReference(new, null)
                                     ensureIdentifier(new, constructorReference)
@@ -90,6 +91,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(foo, expression)
                                   listener: handleNoTypeArguments(.)
@@ -100,6 +102,7 @@
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   inPlainSync()
                                   listener: handleIdentifier(late, expressionContinuation)
@@ -127,6 +130,7 @@
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   inPlainSync()
                                   listener: handleIdentifier(late, expression)
@@ -152,6 +156,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(bar, expression)
                               listener: handleNoTypeArguments(()
@@ -175,6 +180,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -194,6 +200,7 @@
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(late, expressionContinuation)
@@ -219,6 +226,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -237,6 +245,7 @@
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(late, expressionContinuation)
@@ -288,6 +297,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -375,6 +385,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
index 5395458..43bc341 100644
--- a/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/late_modifier.dart.intertwined.expect
@@ -50,6 +50,7 @@
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
                                 parseNewExpression(=)
+                                  isNextIdentifier(new)
                                   listener: beginNewExpression(new)
                                   parseConstructorReference(new, null)
                                     ensureIdentifier(new, constructorReference)
@@ -90,6 +91,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(foo, expression)
                                   listener: handleNoTypeArguments(.)
@@ -100,6 +102,7 @@
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   inPlainSync()
                                   listener: handleIdentifier(late, expressionContinuation)
@@ -127,6 +130,7 @@
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   inPlainSync()
                                   listener: handleIdentifier(late, expression)
@@ -152,6 +156,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(bar, expression)
                               listener: handleNoTypeArguments(()
@@ -175,6 +180,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -194,6 +200,7 @@
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(late, expressionContinuation)
@@ -219,6 +226,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -237,6 +245,7 @@
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(late, expressionContinuation)
@@ -281,6 +290,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(=)
@@ -336,6 +346,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -423,6 +434,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
index bdbfb93..1f6705c 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(.)
@@ -47,6 +48,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(bar, expressionContinuation)
                             listener: handleNoTypeArguments(!)
@@ -58,6 +60,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(baz, expressionContinuation)
                             listener: handleNoTypeArguments([)
@@ -72,6 +75,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
index 34634cc..8f678d0 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckBeforeIndex_with_parens.dart.intertwined.expect
@@ -47,6 +47,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(foo, expression)
                                                 listener: handleNoTypeArguments(.)
@@ -56,6 +57,7 @@
                                         parsePrimary(., expressionContinuation)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(bar, expressionContinuation)
                                               listener: handleNoTypeArguments())
@@ -69,6 +71,7 @@
                         parsePrimary(., expressionContinuation)
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 listener: handleIdentifier(baz, expressionContinuation)
                               listener: handleNoTypeArguments([)
@@ -83,6 +86,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
index df31e84..21d6ac3 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(obj, expression)
                               listener: handleNoTypeArguments(!)
@@ -52,6 +53,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
index 61e8220..835a55b 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(obj, expression)
                               listener: handleNoTypeArguments(!)
@@ -52,6 +53,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
@@ -67,6 +69,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg2, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
index a98f8df..64ea13a 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex2_with_parens.dart.intertwined.expect
@@ -63,6 +63,7 @@
                                                                           parsePrimary((, expression)
                                                                             parseSendOrFunctionLiteral((, expression)
                                                                               parseSend((, expression)
+                                                                                isNextIdentifier(()
                                                                                 ensureIdentifier((, expression)
                                                                                   listener: handleIdentifier(obj, expression)
                                                                                 listener: handleNoTypeArguments(!)
@@ -79,6 +80,7 @@
                                                                 parsePrimary([, expression)
                                                                   parseSendOrFunctionLiteral([, expression)
                                                                     parseSend([, expression)
+                                                                      isNextIdentifier([)
                                                                       ensureIdentifier([, expression)
                                                                         listener: handleIdentifier(arg, expression)
                                                                       listener: handleNoTypeArguments(])
@@ -98,6 +100,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg2, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
index 350b5b0..4d0d581e 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(.)
@@ -47,6 +48,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(bar, expressionContinuation)
                             listener: handleNoTypeArguments(!)
@@ -62,6 +64,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
index 1ce8a71..43d4d51 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex3_with_parens.dart.intertwined.expect
@@ -47,6 +47,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(foo, expression)
                                                 listener: handleNoTypeArguments(.)
@@ -56,6 +57,7 @@
                                         parsePrimary(., expressionContinuation)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(bar, expressionContinuation)
                                               listener: handleNoTypeArguments())
@@ -73,6 +75,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
index c995f0b..53ef115 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(!)
@@ -48,6 +49,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(bar, expressionContinuation)
                             listener: handleNoTypeArguments(!)
@@ -63,6 +65,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
index 4aff390..53029f6 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex4_with_parens.dart.intertwined.expect
@@ -55,6 +55,7 @@
                                                           parsePrimary((, expression)
                                                             parseSendOrFunctionLiteral((, expression)
                                                               parseSend((, expression)
+                                                                isNextIdentifier(()
                                                                 ensureIdentifier((, expression)
                                                                   listener: handleIdentifier(foo, expression)
                                                                 listener: handleNoTypeArguments(!)
@@ -67,6 +68,7 @@
                                         parsePrimary(., expressionContinuation)
                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                             parseSend(., expressionContinuation)
+                                              isNextIdentifier(.)
                                               ensureIdentifier(., expressionContinuation)
                                                 listener: handleIdentifier(bar, expressionContinuation)
                                               listener: handleNoTypeArguments(!)
@@ -84,6 +86,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
index d32485b..d3b5d2b 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(.)
@@ -47,6 +48,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(bar, expressionContinuation)
                             listener: handleNoTypeArguments(!)
@@ -62,6 +64,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
@@ -77,6 +80,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg2, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
index 381b7e2..58b1601 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex5_with_parens.dart.intertwined.expect
@@ -63,6 +63,7 @@
                                                                           parsePrimary((, expression)
                                                                             parseSendOrFunctionLiteral((, expression)
                                                                               parseSend((, expression)
+                                                                                isNextIdentifier(()
                                                                                 ensureIdentifier((, expression)
                                                                                   listener: handleIdentifier(foo, expression)
                                                                                 listener: handleNoTypeArguments(.)
@@ -72,6 +73,7 @@
                                                                         parsePrimary(., expressionContinuation)
                                                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                                                             parseSend(., expressionContinuation)
+                                                                              isNextIdentifier(.)
                                                                               ensureIdentifier(., expressionContinuation)
                                                                                 listener: handleIdentifier(bar, expressionContinuation)
                                                                               listener: handleNoTypeArguments(!)
@@ -89,6 +91,7 @@
                                                                 parsePrimary([, expression)
                                                                   parseSendOrFunctionLiteral([, expression)
                                                                     parseSend([, expression)
+                                                                      isNextIdentifier([)
                                                                       ensureIdentifier([, expression)
                                                                         listener: handleIdentifier(arg, expression)
                                                                       listener: handleNoTypeArguments(])
@@ -108,6 +111,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg2, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
index d994cdc..45e774e 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6.dart.intertwined.expect
@@ -38,6 +38,7 @@
                         parsePrimary({, expression)
                           parseSendOrFunctionLiteral({, expression)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(foo, expression)
                               listener: handleNoTypeArguments(!)
@@ -48,6 +49,7 @@
                       parsePrimary(., expressionContinuation)
                         parseSendOrFunctionLiteral(., expressionContinuation)
                           parseSend(., expressionContinuation)
+                            isNextIdentifier(.)
                             ensureIdentifier(., expressionContinuation)
                               listener: handleIdentifier(bar, expressionContinuation)
                             listener: handleNoTypeArguments(!)
@@ -63,6 +65,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg, expression)
                                     listener: handleNoTypeArguments(])
@@ -78,6 +81,7 @@
                               parsePrimary([, expression)
                                 parseSendOrFunctionLiteral([, expression)
                                   parseSend([, expression)
+                                    isNextIdentifier([)
                                     ensureIdentifier([, expression)
                                       listener: handleIdentifier(arg2, expression)
                                     listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
index 748dbfd..17963ec 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex6_with_parens.dart.intertwined.expect
@@ -71,6 +71,7 @@
                                                                                           parsePrimary((, expression)
                                                                                             parseSendOrFunctionLiteral((, expression)
                                                                                               parseSend((, expression)
+                                                                                                isNextIdentifier(()
                                                                                                 ensureIdentifier((, expression)
                                                                                                   listener: handleIdentifier(foo, expression)
                                                                                                 listener: handleNoTypeArguments(!)
@@ -83,6 +84,7 @@
                                                                         parsePrimary(., expressionContinuation)
                                                                           parseSendOrFunctionLiteral(., expressionContinuation)
                                                                             parseSend(., expressionContinuation)
+                                                                              isNextIdentifier(.)
                                                                               ensureIdentifier(., expressionContinuation)
                                                                                 listener: handleIdentifier(bar, expressionContinuation)
                                                                               listener: handleNoTypeArguments(!)
@@ -100,6 +102,7 @@
                                                                 parsePrimary([, expression)
                                                                   parseSendOrFunctionLiteral([, expression)
                                                                     parseSend([, expression)
+                                                                      isNextIdentifier([)
                                                                       ensureIdentifier([, expression)
                                                                         listener: handleIdentifier(arg, expression)
                                                                       listener: handleNoTypeArguments(])
@@ -119,6 +122,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg2, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
index 355789f..6738bc5 100644
--- a/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/nullCheckOnIndex_with_parens.dart.intertwined.expect
@@ -47,6 +47,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(obj, expression)
                                                 listener: handleNoTypeArguments(!)
@@ -63,6 +64,7 @@
                                 parsePrimary([, expression)
                                   parseSendOrFunctionLiteral([, expression)
                                     parseSend([, expression)
+                                      isNextIdentifier([)
                                       ensureIdentifier([, expression)
                                         listener: handleIdentifier(arg, expression)
                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
index bf3ff98..54a5797 100644
--- a/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/null_shorting_index.dart.intertwined.expect
@@ -72,6 +72,7 @@
                           parsePrimary(=>, expression)
                             parseSendOrFunctionLiteral(=>, expression)
                               parseSend(=>, expression)
+                                isNextIdentifier(=>)
                                 ensureIdentifier(=>, expression)
                                   listener: handleIdentifier(index, expression)
                                 listener: handleNoTypeArguments(;)
@@ -198,6 +199,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?.)
@@ -229,6 +231,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?.)
@@ -266,6 +269,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?)
@@ -305,6 +309,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?)
@@ -354,6 +359,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?)
@@ -393,6 +399,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c1, expression)
                               listener: handleNoTypeArguments(?)
diff --git a/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
index 98b6c31..0a4179e 100644
--- a/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/required_member.dart.intertwined.expect
@@ -50,6 +50,7 @@
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
                                 parseNewExpression(=)
+                                  isNextIdentifier(new)
                                   listener: beginNewExpression(new)
                                   parseConstructorReference(new, null)
                                     ensureIdentifier(new, constructorReference)
@@ -90,6 +91,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(foo, expression)
                                   listener: handleNoTypeArguments(.)
@@ -100,6 +102,7 @@
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   inPlainSync()
                                   listener: handleIdentifier(required, expressionContinuation)
@@ -127,6 +130,7 @@
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   inPlainSync()
                                   listener: handleIdentifier(required, expression)
@@ -152,6 +156,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(bar, expression)
                               listener: handleNoTypeArguments(()
@@ -175,6 +180,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -194,6 +200,7 @@
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(required, expressionContinuation)
@@ -219,6 +226,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -237,6 +245,7 @@
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(required, expressionContinuation)
@@ -288,6 +297,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -375,6 +385,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect b/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
index 48cd79f..0fd59b4 100644
--- a/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/nnbd/required_modifier.dart.intertwined.expect
@@ -50,6 +50,7 @@
                             parseUnaryExpression(=, true)
                               parsePrimary(=, expression)
                                 parseNewExpression(=)
+                                  isNextIdentifier(new)
                                   listener: beginNewExpression(new)
                                   parseConstructorReference(new, null)
                                     ensureIdentifier(new, constructorReference)
@@ -90,6 +91,7 @@
                             parsePrimary(=, expression)
                               parseSendOrFunctionLiteral(=, expression)
                                 parseSend(=, expression)
+                                  isNextIdentifier(=)
                                   ensureIdentifier(=, expression)
                                     listener: handleIdentifier(foo, expression)
                                   listener: handleNoTypeArguments(.)
@@ -100,6 +102,7 @@
                             inPlainSync()
                             parseSendOrFunctionLiteral(., expressionContinuation)
                               parseSend(., expressionContinuation)
+                                isNextIdentifier(.)
                                 ensureIdentifier(., expressionContinuation)
                                   inPlainSync()
                                   listener: handleIdentifier(required, expressionContinuation)
@@ -127,6 +130,7 @@
                             parseSendOrFunctionLiteral(;, expression)
                               looksLikeFunctionBody(;)
                               parseSend(;, expression)
+                                isNextIdentifier(;)
                                 ensureIdentifier(;, expression)
                                   inPlainSync()
                                   listener: handleIdentifier(required, expression)
@@ -152,6 +156,7 @@
                           parseSendOrFunctionLiteral(;, expression)
                             looksLikeFunctionBody(;)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(bar, expression)
                               listener: handleNoTypeArguments(()
@@ -175,6 +180,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -194,6 +200,7 @@
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             looksLikeFunctionBody(;)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(required, expressionContinuation)
@@ -219,6 +226,7 @@
                         parseUnaryExpression(;, true)
                           parsePrimary(;, expression)
                             parseNewExpression(;)
+                              isNextIdentifier(new)
                               listener: beginNewExpression(new)
                               parseConstructorReference(new, null)
                                 ensureIdentifier(new, constructorReference)
@@ -237,6 +245,7 @@
                           inPlainSync()
                           parseSendOrFunctionLiteral(., expressionContinuation)
                             parseSend(., expressionContinuation)
+                              isNextIdentifier(.)
                               ensureIdentifier(., expressionContinuation)
                                 inPlainSync()
                                 listener: handleIdentifier(required, expressionContinuation)
@@ -304,6 +313,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -391,6 +401,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
index 410d504..ccdb9f8 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_39326.dart.intertwined.expect
@@ -57,6 +57,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(c, expression)
                               listener: handleNoTypeArguments(?.)
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
index 433eec8..cd8f064 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional.dart.intertwined.expect
@@ -71,6 +71,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -89,6 +90,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
@@ -97,6 +99,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -113,6 +116,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -128,6 +132,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -149,6 +154,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -167,6 +173,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                         parseExpressionWithoutCascade(:)
@@ -175,6 +182,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -191,6 +199,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -206,6 +215,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -227,6 +237,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -245,12 +256,14 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                   parseArgumentsOpt(toString)
                                     parseArguments(toString)
@@ -261,6 +274,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -277,6 +291,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -288,6 +303,7 @@
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(toString, expressionContinuation)
                                   listener: handleNoTypeArguments(()
@@ -306,6 +322,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -327,6 +344,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -345,12 +363,14 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(b)
                             parsePrimary(., expressionContinuation)
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                   parseArgumentsOpt(toString)
                                     parseArguments(toString)
@@ -361,6 +381,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                     parseArgumentsOpt(c)
                       parseConditionalExpressionRest(a)
@@ -377,6 +398,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(b, expression)
                                               listener: handleNoTypeArguments(])
@@ -388,6 +410,7 @@
                               parseSendOrFunctionLiteral(., expressionContinuation)
                                 looksLikeFunctionBody(:)
                                 parseSend(., expressionContinuation)
+                                  isNextIdentifier(.)
                                   ensureIdentifier(., expressionContinuation)
                                     listener: handleIdentifier(toString, expressionContinuation)
                                   listener: handleNoTypeArguments(()
@@ -406,6 +429,7 @@
                               parsePrimary(:, expression)
                                 parseSendOrFunctionLiteral(:, expression)
                                   parseSend(:, expression)
+                                    isNextIdentifier(:)
                                     ensureIdentifier(:, expression)
                                       listener: handleIdentifier(c, expression)
                                     listener: handleNoTypeArguments(;)
@@ -427,6 +451,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -452,6 +477,7 @@
                                           parsePrimary([, expression)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
+                                                isNextIdentifier([)
                                                 ensureIdentifier([, expression)
                                                   listener: handleIdentifier(b, expression)
                                                 listener: handleNoTypeArguments(])
@@ -478,6 +504,7 @@
                                           parsePrimary([, expression)
                                             parseSendOrFunctionLiteral([, expression)
                                               parseSend([, expression)
+                                                isNextIdentifier([)
                                                 ensureIdentifier([, expression)
                                                   listener: handleIdentifier(c, expression)
                                                 listener: handleNoTypeArguments(])
@@ -500,6 +527,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(a, expression)
                               listener: handleNoTypeArguments(?)
@@ -528,6 +556,7 @@
                                                         parsePrimary([, expression)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
+                                                              isNextIdentifier([)
                                                               ensureIdentifier([, expression)
                                                                 listener: handleIdentifier(b, expression)
                                                               listener: handleNoTypeArguments(])
@@ -559,6 +588,7 @@
                                                         parsePrimary([, expression)
                                                           parseSendOrFunctionLiteral([, expression)
                                                             parseSend([, expression)
+                                                              isNextIdentifier([)
                                                               ensureIdentifier([, expression)
                                                                 listener: handleIdentifier(c, expression)
                                                               listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
index 2b95e24..6c1ac05 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_2.dart.intertwined.expect
@@ -63,6 +63,7 @@
                       parsePrimary(return, expression)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(a, expression)
                             listener: handleNoTypeArguments(?)
@@ -82,6 +83,7 @@
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                             parseArgumentsOpt(b)
                                               parseArguments(b)
@@ -114,6 +116,7 @@
                                         parseSendOrFunctionLiteral([, expression)
                                           looksLikeFunctionBody(])
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                               listener: handleIdentifier(b, expression)
                                             listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
index ba903a4..2e8a975f 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_3.dart.intertwined.expect
@@ -56,6 +56,7 @@
                       parsePrimary(return, expression)
                         parseSendOrFunctionLiteral(return, expression)
                           parseSend(return, expression)
+                            isNextIdentifier(return)
                             ensureIdentifier(return, expression)
                               listener: handleIdentifier(a, expression)
                             listener: handleNoTypeArguments(!=)
@@ -80,6 +81,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                               parseArgumentsOpt(a)
                         parseExpressionWithoutCascade(:)
@@ -104,6 +106,7 @@
                                       parsePrimary([, expression)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                             parseArgumentsOpt(a)
                       parseExpressionWithoutCascade(:)
@@ -129,6 +132,7 @@
                                       parsePrimary([, expression)
                                         parseSendOrFunctionLiteral([, expression)
                                           parseSend([, expression)
+                                            isNextIdentifier([)
                                             ensureIdentifier([, expression)
                                               listener: handleIdentifier(a, expression)
                                             listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
index ffb0a66..06fa097 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40267_conditional_4.dart.intertwined.expect
@@ -61,6 +61,7 @@
                   parsePrimary(=>, expression)
                     parseSendOrFunctionLiteral(=>, expression)
                       parseSend(=>, expression)
+                        isNextIdentifier(=>)
                         ensureIdentifier(=>, expression)
                           listener: handleIdentifier(a, expression)
                         listener: handleNoTypeArguments(..)
@@ -70,6 +71,7 @@
                 parseCascadeExpression(a)
                   listener: beginCascade(..)
                   parseSend(.., expressionContinuation)
+                    isNextIdentifier(..)
                     ensureIdentifier(.., expressionContinuation)
                       listener: handleIdentifier(addAll, expressionContinuation)
                     listener: handleNoTypeArguments(()
@@ -85,6 +87,7 @@
                                     parsePrimary(!, expression)
                                       parseSendOrFunctionLiteral(!, expression)
                                         parseSend(!, expression)
+                                          isNextIdentifier(!)
                                           ensureIdentifier(!, expression)
                                             listener: handleIdentifier(b, expression)
                                           listener: handleNoTypeArguments(&&)
@@ -98,6 +101,7 @@
                                   parsePrimary(&&, expression)
                                     parseSendOrFunctionLiteral(&&, expression)
                                       parseSend(&&, expression)
+                                        isNextIdentifier(&&)
                                         ensureIdentifier(&&, expression)
                                           listener: handleIdentifier(c, expression)
                                         listener: handleNoTypeArguments([)
@@ -111,6 +115,7 @@
                                         parsePrimary([, expression)
                                           parseSendOrFunctionLiteral([, expression)
                                             parseSend([, expression)
+                                              isNextIdentifier([)
                                               ensureIdentifier([, expression)
                                                 listener: handleIdentifier(d, expression)
                                               listener: handleNoTypeArguments(])
@@ -130,6 +135,7 @@
                                                     parsePrimary([, expression)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
+                                                          isNextIdentifier([)
                                                           ensureIdentifier([, expression)
                                                           parseArgumentsOpt(a)
                                               parseExpression(,)
@@ -139,6 +145,7 @@
                                                       parseSendOrFunctionLiteral(,, expression)
                                                         looksLikeFunctionBody(])
                                                         parseSend(,, expression)
+                                                          isNextIdentifier(,)
                                                           ensureIdentifier(,, expression)
                                                           parseArgumentsOpt(e)
                                                             parseArguments(e)
@@ -149,6 +156,7 @@
                                                                       parsePrimary((, expression)
                                                                         parseSendOrFunctionLiteral((, expression)
                                                                           parseSend((, expression)
+                                                                            isNextIdentifier(()
                                                                             ensureIdentifier((, expression)
                                                                             parseArgumentsOpt(f)
                                     parseExpressionWithoutCascade(:)
@@ -162,6 +170,7 @@
                                                     parsePrimary([, expression)
                                                       parseSendOrFunctionLiteral([, expression)
                                                         parseSend([, expression)
+                                                          isNextIdentifier([)
                                                           ensureIdentifier([, expression)
                                                           parseArgumentsOpt(a)
                                 canParseAsConditional(?)
@@ -176,6 +185,7 @@
                                                   parsePrimary([, expression)
                                                     parseSendOrFunctionLiteral([, expression)
                                                       parseSend([, expression)
+                                                        isNextIdentifier([)
                                                         ensureIdentifier([, expression)
                                                         parseArgumentsOpt(a)
                                             parseExpression(,)
@@ -185,6 +195,7 @@
                                                     parseSendOrFunctionLiteral(,, expression)
                                                       looksLikeFunctionBody(])
                                                       parseSend(,, expression)
+                                                        isNextIdentifier(,)
                                                         ensureIdentifier(,, expression)
                                                         parseArgumentsOpt(e)
                                                           parseArguments(e)
@@ -195,6 +206,7 @@
                                                                     parsePrimary((, expression)
                                                                       parseSendOrFunctionLiteral((, expression)
                                                                         parseSend((, expression)
+                                                                          isNextIdentifier(()
                                                                           ensureIdentifier((, expression)
                                                                           parseArgumentsOpt(f)
                                   parseExpressionWithoutCascade(:)
@@ -208,6 +220,7 @@
                                                   parsePrimary([, expression)
                                                     parseSendOrFunctionLiteral([, expression)
                                                       parseSend([, expression)
+                                                        isNextIdentifier([)
                                                         ensureIdentifier([, expression)
                                                         parseArgumentsOpt(a)
                               listener: endBinaryExpression(&&)
@@ -223,6 +236,7 @@
                                                 parsePrimary([, expression)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
+                                                      isNextIdentifier([)
                                                       ensureIdentifier([, expression)
                                                       parseArgumentsOpt(a)
                                           parseExpression(,)
@@ -232,6 +246,7 @@
                                                   parseSendOrFunctionLiteral(,, expression)
                                                     looksLikeFunctionBody(])
                                                     parseSend(,, expression)
+                                                      isNextIdentifier(,)
                                                       ensureIdentifier(,, expression)
                                                       parseArgumentsOpt(e)
                                                         parseArguments(e)
@@ -242,6 +257,7 @@
                                                                   parsePrimary((, expression)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
+                                                                        isNextIdentifier(()
                                                                         ensureIdentifier((, expression)
                                                                         parseArgumentsOpt(f)
                                 parseExpressionWithoutCascade(:)
@@ -255,6 +271,7 @@
                                                 parsePrimary([, expression)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
+                                                      isNextIdentifier([)
                                                       ensureIdentifier([, expression)
                                                       parseArgumentsOpt(a)
                               parseConditionalExpressionRest(])
@@ -271,6 +288,7 @@
                                                 parsePrimary([, expression)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
+                                                      isNextIdentifier([)
                                                       ensureIdentifier([, expression)
                                                         listener: handleIdentifier(a, expression)
                                                       listener: handleNoTypeArguments(,)
@@ -284,6 +302,7 @@
                                                   parseSendOrFunctionLiteral(,, expression)
                                                     looksLikeFunctionBody(])
                                                     parseSend(,, expression)
+                                                      isNextIdentifier(,)
                                                       ensureIdentifier(,, expression)
                                                         listener: handleIdentifier(e, expression)
                                                       listener: handleNoTypeArguments(()
@@ -297,6 +316,7 @@
                                                                   parsePrimary((, expression)
                                                                     parseSendOrFunctionLiteral((, expression)
                                                                       parseSend((, expression)
+                                                                        isNextIdentifier(()
                                                                         ensureIdentifier((, expression)
                                                                           listener: handleIdentifier(f, expression)
                                                                         listener: handleNoTypeArguments())
@@ -320,6 +340,7 @@
                                                 parsePrimary([, expression)
                                                   parseSendOrFunctionLiteral([, expression)
                                                     parseSend([, expression)
+                                                      isNextIdentifier([)
                                                       ensureIdentifier([, expression)
                                                         listener: handleIdentifier(a, expression)
                                                       listener: handleNoTypeArguments(])
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
index 7c38bab..9d357bc 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40288.dart.intertwined.expect
@@ -178,6 +178,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(late, expression)
                               listener: handleNoTypeArguments(()
@@ -212,6 +213,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(required, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
index 715a0d3..94ff34e 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/issue_40288_prime.dart.intertwined.expect
@@ -178,6 +178,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Xlate, expression)
                               listener: handleNoTypeArguments(()
@@ -212,6 +213,7 @@
                           parseSendOrFunctionLiteral(=, expression)
                             looksLikeFunctionBody(;)
                             parseSend(=, expression)
+                              isNextIdentifier(=)
                               ensureIdentifier(=, expression)
                                 listener: handleIdentifier(Xrequired, expression)
                               listener: handleNoTypeArguments(()
diff --git a/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
index 350fa9e..cab97bd 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/use_late_in_non_nnbd.dart.intertwined.expect
@@ -313,6 +313,7 @@
                         parsePrimary(;, expression)
                           parseSendOrFunctionLiteral(;, expression)
                             parseSend(;, expression)
+                              isNextIdentifier(;)
                               ensureIdentifier(;, expression)
                                 listener: handleIdentifier(late, expression)
                               listener: handleNoTypeArguments(;)
diff --git a/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect b/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
index baad9f3..20f8cf3 100644
--- a/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/non-nnbd/use_required_in_non_nnbd.dart.intertwined.expect
@@ -56,6 +56,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -69,6 +70,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments())
@@ -135,6 +137,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -148,6 +151,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments())
@@ -216,6 +220,7 @@
                           parseSendOrFunctionLiteral({, expression)
                             looksLikeFunctionBody(;)
                             parseSend({, expression)
+                              isNextIdentifier({)
                               ensureIdentifier({, expression)
                                 listener: handleIdentifier(print, expression)
                               listener: handleNoTypeArguments(()
@@ -229,6 +234,7 @@
                                           parsePrimary((, expression)
                                             parseSendOrFunctionLiteral((, expression)
                                               parseSend((, expression)
+                                                isNextIdentifier(()
                                                 ensureIdentifier((, expression)
                                                   listener: handleIdentifier(x, expression)
                                                 listener: handleNoTypeArguments())
@@ -325,6 +331,7 @@
                                   parseSendOrFunctionLiteral({, expression)
                                     looksLikeFunctionBody(;)
                                     parseSend({, expression)
+                                      isNextIdentifier({)
                                       ensureIdentifier({, expression)
                                         listener: handleIdentifier(print, expression)
                                       listener: handleNoTypeArguments(()
@@ -338,6 +345,7 @@
                                                   parsePrimary((, expression)
                                                     parseSendOrFunctionLiteral((, expression)
                                                       parseSend((, expression)
+                                                        isNextIdentifier(()
                                                         ensureIdentifier((, expression)
                                                           listener: handleIdentifier(x, expression)
                                                         listener: handleNoTypeArguments())
diff --git a/pkg/front_end/test/constant_evaluator_benchmark.dart b/pkg/front_end/test/constant_evaluator_benchmark.dart
index 77b6084..c1eb8fb 100644
--- a/pkg/front_end/test/constant_evaluator_benchmark.dart
+++ b/pkg/front_end/test/constant_evaluator_benchmark.dart
@@ -101,6 +101,8 @@
             evaluateAnnotations: true,
             enableTripleShift: target
                 .isExperimentEnabledGlobally(ExperimentalFlag.tripleShift),
+            enableConstFunctions: target
+                .isExperimentEnabledGlobally(ExperimentalFlag.constFunctions),
             errorOnUnevaluatedConstant:
                 incrementalCompiler.context.options.errorOnUnevaluatedConstant);
         print("Transformed constants with $environmentDefinesDescription"
diff --git a/pkg/front_end/test/generated_files_up_to_date_git_test.dart b/pkg/front_end/test/generated_files_up_to_date_git_test.dart
new file mode 100644
index 0000000..47f7548
--- /dev/null
+++ b/pkg/front_end/test/generated_files_up_to_date_git_test.dart
@@ -0,0 +1,99 @@
+// Copyright (c) 2021, 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.md file.
+
+// @dart = 2.9
+
+import "dart:io" show File, exitCode;
+
+import "../tool/_fasta/generate_messages.dart" as generateMessages;
+import "../tool/_fasta/generate_experimental_flags.dart"
+    as generateExperimentalFlags;
+import "../tool/_fasta/direct_parser_ast_helper_creator.dart"
+    as generateDirectParserAstHelper;
+import "parser_test_listener_creator.dart" as generateParserTestListener;
+import "parser_test_parser_creator.dart" as generateParserTestParser;
+import 'utils/io_utils.dart' show computeRepoDirUri;
+
+final Uri repoDir = computeRepoDirUri();
+
+main() {
+  messages();
+  experimentalFlags();
+  directParserAstHelper();
+  parserTestListener();
+  parserTestParser();
+}
+
+void parserTestParser() {
+  Uri generatedFile = generateParserTestParser.computeTestParserUri(repoDir);
+  String generated = generateParserTestParser.generateTestParser(repoDir);
+  check(generated, generatedFile,
+      "dart pkg/front_end/test/parser_test_parser_creator.dart");
+}
+
+void parserTestListener() {
+  Uri generatedFile =
+      generateParserTestListener.computeTestListenerUri(repoDir);
+  String generated = generateParserTestListener.generateTestListener(repoDir);
+  check(generated, generatedFile,
+      "dart pkg/front_end/test/parser_test_listener_creator.dart");
+}
+
+void directParserAstHelper() {
+  Uri generatedFile =
+      generateDirectParserAstHelper.computeAstHelperUri(repoDir);
+  String generated = generateDirectParserAstHelper.generateAstHelper(repoDir);
+  check(generated, generatedFile,
+      "dart pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart");
+}
+
+void experimentalFlags() {
+  {
+    Uri generatedFile =
+        generateExperimentalFlags.computeCfeGeneratedFile(repoDir);
+    String generated = generateExperimentalFlags.generateCfeFile(repoDir);
+    check(generated, generatedFile,
+        "dart pkg/front_end/tool/fasta.dart generate-experimental-flags");
+  }
+  {
+    Uri generatedFile =
+        generateExperimentalFlags.computeKernelGeneratedFile(repoDir);
+    String generated = generateExperimentalFlags.generateKernelFile(repoDir);
+    check(generated, generatedFile,
+        "dart pkg/front_end/tool/fasta.dart generate-experimental-flags");
+  }
+}
+
+void messages() {
+  generateMessages.Messages messages =
+      generateMessages.generateMessagesFiles(repoDir);
+
+  Uri generatedFile = generateMessages.computeSharedGeneratedFile(repoDir);
+  check(messages.sharedMessages, generatedFile,
+      "dart pkg/front_end/tool/fasta.dart generate-messages");
+
+  Uri cfeGeneratedFile = generateMessages.computeCfeGeneratedFile(repoDir);
+  check(messages.cfeMessages, cfeGeneratedFile,
+      "dart pkg/front_end/tool/fasta.dart generate-messages");
+}
+
+void check(String generated, Uri generatedFile, String run) {
+  String actual = new File.fromUri(generatedFile)
+      .readAsStringSync()
+      .replaceAll('\r\n', '\n');
+  if (generated != actual) {
+    print("""
+------------------------
+
+The generated file
+  ${generatedFile.path}
+
+is out of date. To regenerate the file, run
+  $run
+
+------------------------
+""");
+    exitCode = 1;
+  }
+}
diff --git a/pkg/front_end/test/parser_test_listener.dart b/pkg/front_end/test/parser_test_listener.dart
index 8ffa24f..c3a0373 100644
--- a/pkg/front_end/test/parser_test_listener.dart
+++ b/pkg/front_end/test/parser_test_listener.dart
@@ -2,8 +2,6 @@
 // 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.
 
-// @dart=2.12
-
 import 'package:_fe_analyzer_shared/src/parser/assert.dart';
 import 'package:_fe_analyzer_shared/src/parser/block_kind.dart';
 import 'package:_fe_analyzer_shared/src/parser/declaration_kind.dart';
@@ -13,16 +11,11 @@
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
 import 'package:_fe_analyzer_shared/src/scanner/error_token.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
-// ignore: import_of_legacy_library_into_null_safe
 import 'package:front_end/src/fasta/messages.dart';
 
 // THIS FILE IS AUTO GENERATED BY 'test/parser_test_listener_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/test/parser_test_listener_creator.dart \
-      > pkg/front_end/test/parser_test_listener.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/test/parser_test_listener_creator.dart'
 
 class ParserTestListener implements Listener {
   int indent = 0;
diff --git a/pkg/front_end/test/parser_test_listener_creator.dart b/pkg/front_end/test/parser_test_listener_creator.dart
index 64edd83..b4f5fc9 100644
--- a/pkg/front_end/test/parser_test_listener_creator.dart
+++ b/pkg/front_end/test/parser_test_listener_creator.dart
@@ -4,25 +4,32 @@
 
 // @dart=2.9
 
-import 'dart:io';
-import 'dart:typed_data';
+import 'dart:io' show File;
+import 'dart:typed_data' show Uint8List;
 
 import 'package:_fe_analyzer_shared/src/parser/parser.dart';
 import 'package:_fe_analyzer_shared/src/scanner/utf8_bytes_scanner.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
+
 import 'package:dart_style/dart_style.dart' show DartFormatter;
 
-StringSink out;
+import 'utils/io_utils.dart' show computeRepoDirUri;
 
 main(List<String> args) {
-  if (args.contains("--stdout")) {
-    out = stdout;
-  } else {
-    out = new StringBuffer();
-  }
+  final Uri repoDir = computeRepoDirUri();
+  String generated = generateTestListener(repoDir);
+  new File.fromUri(computeTestListenerUri(repoDir))
+      .writeAsStringSync(generated, flush: true);
+}
 
-  File f = new File.fromUri(Platform.script
-      .resolve("../../_fe_analyzer_shared/lib/src/parser/listener.dart"));
+Uri computeTestListenerUri(Uri repoDir) {
+  return repoDir.resolve("pkg/front_end/test/parser_test_listener.dart");
+}
+
+String generateTestListener(Uri repoDir) {
+  final StringBuffer out = new StringBuffer();
+  File f = new File.fromUri(
+      repoDir.resolve("pkg/_fe_analyzer_shared/lib/src/parser/listener.dart"));
   List<int> rawBytes = f.readAsBytesSync();
 
   Uint8List bytes = new Uint8List(rawBytes.length + 1);
@@ -36,8 +43,6 @@
 // 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.
 
-// @dart=2.12
-
 import 'package:_fe_analyzer_shared/src/parser/assert.dart';
 import 'package:_fe_analyzer_shared/src/parser/block_kind.dart';
 import 'package:_fe_analyzer_shared/src/parser/declaration_kind.dart';
@@ -47,16 +52,11 @@
 import 'package:_fe_analyzer_shared/src/parser/member_kind.dart';
 import 'package:_fe_analyzer_shared/src/scanner/error_token.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
-// ignore: import_of_legacy_library_into_null_safe
 import 'package:front_end/src/fasta/messages.dart';
 
 // THIS FILE IS AUTO GENERATED BY 'test/parser_test_listener_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/test/parser_test_listener_creator.dart \
-      > pkg/front_end/test/parser_test_listener.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/test/parser_test_listener_creator.dart'
 
 class ParserTestListener implements Listener {
   int indent = 0;
@@ -107,29 +107,25 @@
 
 """);
 
-  ParserCreatorListener listener = new ParserCreatorListener();
+  ParserCreatorListener listener = new ParserCreatorListener(out);
   ClassMemberParser parser = new ClassMemberParser(listener);
   parser.parseUnit(firstToken);
 
   out.writeln("}");
 
-  if (out is StringBuffer) {
-    String text = new DartFormatter().format("$out");
-    if (args.isNotEmpty) {
-      new File(args.first).writeAsStringSync(text);
-    } else {
-      stdout.write(text);
-    }
-  }
+  return new DartFormatter().format("$out");
 }
 
 class ParserCreatorListener extends Listener {
+  final StringSink out;
   bool insideListenerClass = false;
   String currentMethodName;
   String latestSeenParameterTypeToken;
   List<String> parameters = <String>[];
   List<String> parameterTypes = <String>[];
 
+  ParserCreatorListener(this.out);
+
   void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
     if (name.lexeme == "Listener") insideListenerClass = true;
   }
diff --git a/pkg/front_end/test/parser_test_parser.dart b/pkg/front_end/test/parser_test_parser.dart
index 8aa6d40..2eb3a9a 100644
--- a/pkg/front_end/test/parser_test_parser.dart
+++ b/pkg/front_end/test/parser_test_parser.dart
@@ -2,8 +2,6 @@
 // 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.
 
-// @dart = 2.9
-
 import 'package:_fe_analyzer_shared/src/parser/assert.dart';
 import 'package:_fe_analyzer_shared/src/parser/block_kind.dart';
 import 'package:_fe_analyzer_shared/src/parser/declaration_kind.dart';
@@ -16,15 +14,11 @@
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/parser/type_info.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
-import 'package:front_end/src/fasta/fasta_codes.dart';
+import 'package:front_end/src/fasta/fasta_codes.dart' as codes;
 
 // THIS FILE IS AUTO GENERATED BY 'test/parser_test_parser_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/test/parser_test_parser_creator.dart \
-      > pkg/front_end/test/parser_test_parser.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/test/parser_test_parser_creator.dart'
 
 class TestParser extends Parser {
   int indent = 0;
@@ -53,7 +47,7 @@
     sb.writeln(("  " * indent) + s + traceString);
   }
 
-  Uri get uri {
+  Uri? get uri {
     doPrint('uri()');
     indent++;
     var result = super.uri;
@@ -142,7 +136,7 @@
   }
 
   Token parseTopLevelDeclarationImpl(
-      Token token, DirectiveContext directiveState) {
+      Token token, DirectiveContext? directiveState) {
     doPrint('parseTopLevelDeclarationImpl(' '$token, ' '$directiveState)');
     indent++;
     var result = super.parseTopLevelDeclarationImpl(token, directiveState);
@@ -150,7 +144,7 @@
     return result;
   }
 
-  Token parseClassDeclarationModifiers(Token start, Token keyword) {
+  Token? parseClassDeclarationModifiers(Token start, Token keyword) {
     doPrint('parseClassDeclarationModifiers(' '$start, ' '$keyword)');
     indent++;
     var result = super.parseClassDeclarationModifiers(start, keyword);
@@ -175,7 +169,7 @@
   }
 
   Token parseTopLevelKeywordDeclaration(
-      Token start, Token keyword, DirectiveContext directiveState) {
+      Token start, Token keyword, DirectiveContext? directiveState) {
     doPrint('parseTopLevelKeywordDeclaration('
         '$start, '
         '$keyword, '
@@ -291,7 +285,7 @@
     return result;
   }
 
-  Token parsePartOrPartOf(Token partKeyword, DirectiveContext directiveState) {
+  Token parsePartOrPartOf(Token partKeyword, DirectiveContext? directiveState) {
     doPrint('parsePartOrPartOf(' '$partKeyword, ' '$directiveState)');
     indent++;
     var result = super.parsePartOrPartOf(partKeyword, directiveState);
@@ -425,7 +419,7 @@
     return result;
   }
 
-  Message missingParameterMessage(MemberKind kind) {
+  codes.Message missingParameterMessage(MemberKind kind) {
     doPrint('missingParameterMessage(' '$kind)');
     indent++;
     var result = super.missingParameterMessage(kind);
@@ -502,7 +496,7 @@
   }
 
   Token parseClassOrNamedMixinApplication(
-      Token abstractToken, Token classKeyword) {
+      Token? abstractToken, Token classKeyword) {
     doPrint('parseClassOrNamedMixinApplication('
         '$abstractToken, '
         '$classKeyword)');
@@ -557,6 +551,16 @@
     return result;
   }
 
+  Token parseClassExtendsSeenExtendsClause(Token extendsKeyword, Token token) {
+    doPrint(
+        'parseClassExtendsSeenExtendsClause(' '$extendsKeyword, ' '$token)');
+    indent++;
+    var result =
+        super.parseClassExtendsSeenExtendsClause(extendsKeyword, token);
+    indent--;
+    return result;
+  }
+
   Token parseClassOrMixinImplementsOpt(Token token) {
     doPrint('parseClassOrMixinImplementsOpt(' '$token)');
     indent++;
@@ -627,7 +631,7 @@
   }
 
   Token insertSyntheticIdentifier(Token token, IdentifierContext context,
-      {Message message, Token messageOnToken}) {
+      {codes.Message? message, Token? messageOnToken}) {
     doPrint('insertSyntheticIdentifier('
         '$token, '
         '$context, '
@@ -648,6 +652,14 @@
     return result;
   }
 
+  bool isNextIdentifier(Token token) {
+    doPrint('isNextIdentifier(' '$token)');
+    indent++;
+    var result = super.isNextIdentifier(token);
+    indent--;
+    return result;
+  }
+
   Token ensureIdentifierPotentiallyRecovered(
       Token token, IdentifierContext context, bool isRecovered) {
     doPrint('ensureIdentifierPotentiallyRecovered('
@@ -695,17 +707,17 @@
 
   Token parseFields(
       Token beforeStart,
-      Token abstractToken,
-      Token externalToken,
-      Token staticToken,
-      Token covariantToken,
-      Token lateToken,
-      Token varFinalOrConst,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
       Token beforeType,
       TypeInfo typeInfo,
       Token name,
       DeclarationKind kind,
-      String enclosingDeclarationName,
+      String? enclosingDeclarationName,
       bool nameIsRecovered) {
     doPrint('parseFields('
         '$beforeStart, '
@@ -742,10 +754,10 @@
 
   Token parseTopLevelMethod(
       Token beforeStart,
-      Token externalToken,
+      Token? externalToken,
       Token beforeType,
       TypeInfo typeInfo,
-      Token getOrSet,
+      Token? getOrSet,
       Token name,
       bool nameIsRecovered) {
     doPrint('parseTopLevelMethod('
@@ -774,12 +786,12 @@
   Token parseFieldInitializerOpt(
       Token token,
       Token name,
-      Token lateToken,
-      Token abstractToken,
-      Token externalToken,
-      Token varFinalOrConst,
+      Token? lateToken,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? varFinalOrConst,
       DeclarationKind kind,
-      String enclosingDeclarationName) {
+      String? enclosingDeclarationName) {
     doPrint('parseFieldInitializerOpt('
         '$token, '
         '$name, '
@@ -853,8 +865,8 @@
 
   Token ensureBlock(
       Token token,
-      Template<Message Function(Token token)> template,
-      String missingBlockName) {
+      codes.Template<codes.Message Function(Token token)>? template,
+      String? missingBlockName) {
     doPrint('ensureBlock(' '$token, ' '$template, ' '$missingBlockName)');
     indent++;
     var result = super.ensureBlock(token, template, missingBlockName);
@@ -902,7 +914,7 @@
     return result;
   }
 
-  Token rewriteAndRecover(Token token, Message message, Token newToken) {
+  Token rewriteAndRecover(Token token, codes.Message message, Token newToken) {
     doPrint('rewriteAndRecover(' '$token, ' '$message, ' '$newToken)');
     indent++;
     var result = super.rewriteAndRecover(token, message, newToken);
@@ -943,7 +955,7 @@
   }
 
   Token parseClassOrMixinOrExtensionBody(
-      Token token, DeclarationKind kind, String enclosingDeclarationName) {
+      Token token, DeclarationKind kind, String? enclosingDeclarationName) {
     doPrint('parseClassOrMixinOrExtensionBody('
         '$token, '
         '$kind, '
@@ -1004,7 +1016,7 @@
   }
 
   Token parseClassOrMixinOrExtensionMemberImpl(
-      Token token, DeclarationKind kind, String enclosingDeclarationName) {
+      Token token, DeclarationKind kind, String? enclosingDeclarationName) {
     doPrint('parseClassOrMixinOrExtensionMemberImpl('
         '$token, '
         '$kind, '
@@ -1018,18 +1030,18 @@
 
   Token parseMethod(
       Token beforeStart,
-      Token abstractToken,
-      Token externalToken,
-      Token staticToken,
-      Token covariantToken,
-      Token lateToken,
-      Token varFinalOrConst,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
       Token beforeType,
       TypeInfo typeInfo,
-      Token getOrSet,
+      Token? getOrSet,
       Token name,
       DeclarationKind kind,
-      String enclosingDeclarationName,
+      String? enclosingDeclarationName,
       bool nameIsRecovered) {
     doPrint('parseMethod('
         '$beforeStart, '
@@ -1067,7 +1079,7 @@
   }
 
   Token parseFactoryMethod(Token token, DeclarationKind kind, Token beforeStart,
-      Token externalToken, Token staticOrCovariant, Token varFinalOrConst) {
+      Token? externalToken, Token? staticOrCovariant, Token? varFinalOrConst) {
     doPrint('parseFactoryMethod('
         '$token, '
         '$kind, '
@@ -1146,7 +1158,7 @@
     return result;
   }
 
-  Token parseConstructorReference(Token token, [TypeParamOrArgInfo typeArg]) {
+  Token parseConstructorReference(Token token, [TypeParamOrArgInfo? typeArg]) {
     doPrint('parseConstructorReference(' '$token, ' '$typeArg)');
     indent++;
     var result = super.parseConstructorReference(token, typeArg);
@@ -1401,7 +1413,7 @@
     return result;
   }
 
-  Token parseLiteralListSuffix(Token token, Token constKeyword) {
+  Token parseLiteralListSuffix(Token token, Token? constKeyword) {
     doPrint('parseLiteralListSuffix(' '$token, ' '$constKeyword)');
     indent++;
     var result = super.parseLiteralListSuffix(token, constKeyword);
@@ -1409,7 +1421,7 @@
     return result;
   }
 
-  Token parseLiteralSetOrMapSuffix(Token token, Token constKeyword) {
+  Token parseLiteralSetOrMapSuffix(Token token, Token? constKeyword) {
     doPrint('parseLiteralSetOrMapSuffix(' '$token, ' '$constKeyword)');
     indent++;
     var result = super.parseLiteralSetOrMapSuffix(token, constKeyword);
@@ -1426,7 +1438,7 @@
   }
 
   Token parseLiteralListSetMapOrFunction(
-      final Token start, Token constKeyword) {
+      final Token start, Token? constKeyword) {
     doPrint('parseLiteralListSetMapOrFunction(' '$start, ' '$constKeyword)');
     indent++;
     var result = super.parseLiteralListSetMapOrFunction(start, constKeyword);
@@ -1664,11 +1676,11 @@
   }
 
   Token parseExpressionStatementOrDeclarationAfterModifiers(
-      final Token beforeType,
-      final Token start,
-      final Token lateToken,
-      Token varFinalOrConst,
-      TypeInfo typeInfo,
+      Token beforeType,
+      Token start,
+      Token? lateToken,
+      Token? varFinalOrConst,
+      TypeInfo? typeInfo,
       bool onlyParseVariableDeclarationStart) {
     doPrint('parseExpressionStatementOrDeclarationAfterModifiers('
         '$beforeType, '
@@ -1713,7 +1725,7 @@
     return result;
   }
 
-  Token parseForStatement(Token token, Token awaitToken) {
+  Token parseForStatement(Token token, Token? awaitToken) {
     doPrint('parseForStatement(' '$token, ' '$awaitToken)');
     indent++;
     var result = super.parseForStatement(token, awaitToken);
@@ -1721,7 +1733,7 @@
     return result;
   }
 
-  Token parseForLoopPartsStart(Token awaitToken, Token forToken) {
+  Token parseForLoopPartsStart(Token? awaitToken, Token forToken) {
     doPrint('parseForLoopPartsStart(' '$awaitToken, ' '$forToken)');
     indent++;
     var result = super.parseForLoopPartsStart(awaitToken, forToken);
@@ -1729,7 +1741,7 @@
     return result;
   }
 
-  Token parseForLoopPartsMid(Token token, Token awaitToken, Token forToken) {
+  Token parseForLoopPartsMid(Token token, Token? awaitToken, Token forToken) {
     doPrint('parseForLoopPartsMid(' '$token, ' '$awaitToken, ' '$forToken)');
     indent++;
     var result = super.parseForLoopPartsMid(token, awaitToken, forToken);
@@ -1737,7 +1749,7 @@
     return result;
   }
 
-  Token parseForRest(Token awaitToken, Token token, Token forToken) {
+  Token parseForRest(Token? awaitToken, Token token, Token forToken) {
     doPrint('parseForRest(' '$awaitToken, ' '$token, ' '$forToken)');
     indent++;
     var result = super.parseForRest(awaitToken, token, forToken);
@@ -1745,7 +1757,7 @@
     return result;
   }
 
-  Token parseForLoopPartsRest(Token token, Token forToken, Token awaitToken) {
+  Token parseForLoopPartsRest(Token token, Token forToken, Token? awaitToken) {
     doPrint('parseForLoopPartsRest(' '$token, ' '$forToken, ' '$awaitToken)');
     indent++;
     var result = super.parseForLoopPartsRest(token, forToken, awaitToken);
@@ -1754,7 +1766,7 @@
   }
 
   Token parseForInRest(
-      Token token, Token awaitToken, Token forToken, Token identifier) {
+      Token token, Token? awaitToken, Token forToken, Token identifier) {
     doPrint('parseForInRest('
         '$token, '
         '$awaitToken, '
@@ -1767,7 +1779,7 @@
   }
 
   Token parseForInLoopPartsRest(
-      Token token, Token awaitToken, Token forToken, Token identifier) {
+      Token token, Token? awaitToken, Token forToken, Token identifier) {
     doPrint('parseForInLoopPartsRest('
         '$token, '
         '$awaitToken, '
@@ -1898,8 +1910,8 @@
       Token begin,
       int labelCount,
       int expressionCount,
-      Token defaultKeyword,
-      Token colonAfterDefault) {
+      Token? defaultKeyword,
+      Token? colonAfterDefault) {
     doPrint('parseStatementsInSwitchCase('
         '$token, '
         '$peek, '
@@ -1965,15 +1977,15 @@
 
   Token parseInvalidOperatorDeclaration(
       Token beforeStart,
-      Token abstractToken,
-      Token externalToken,
-      Token staticToken,
-      Token covariantToken,
-      Token lateToken,
-      Token varFinalOrConst,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
       Token beforeType,
       DeclarationKind kind,
-      String enclosingDeclarationName) {
+      String? enclosingDeclarationName) {
     doPrint('parseInvalidOperatorDeclaration('
         '$beforeStart, '
         '$abstractToken, '
@@ -2004,17 +2016,17 @@
   Token recoverFromInvalidMember(
       Token token,
       Token beforeStart,
-      Token abstractToken,
-      Token externalToken,
-      Token staticToken,
-      Token covariantToken,
-      Token lateToken,
-      Token varFinalOrConst,
+      Token? abstractToken,
+      Token? externalToken,
+      Token? staticToken,
+      Token? covariantToken,
+      Token? lateToken,
+      Token? varFinalOrConst,
       Token beforeType,
       TypeInfo typeInfo,
-      Token getOrSet,
+      Token? getOrSet,
       DeclarationKind kind,
-      String enclosingDeclarationName) {
+      String? enclosingDeclarationName) {
     doPrint('recoverFromInvalidMember('
         '$token, '
         '$beforeStart, '
@@ -2056,7 +2068,7 @@
     return result;
   }
 
-  void reportRecoverableError(Token token, Message message) {
+  void reportRecoverableError(Token token, codes.Message message) {
     doPrint('reportRecoverableError(' '$token, ' '$message)');
     indent++;
     var result = super.reportRecoverableError(token, message);
@@ -2064,6 +2076,19 @@
     return result;
   }
 
+  void reportRecoverableErrorWithEnd(
+      Token startToken, Token endToken, codes.Message message) {
+    doPrint('reportRecoverableErrorWithEnd('
+        '$startToken, '
+        '$endToken, '
+        '$message)');
+    indent++;
+    var result =
+        super.reportRecoverableErrorWithEnd(startToken, endToken, message);
+    indent--;
+    return result;
+  }
+
   void reportRecoverableErrorWithToken(Token token, dynamic template) {
     doPrint('reportRecoverableErrorWithToken(' '$token, ' '$template)');
     indent++;
@@ -2136,7 +2161,7 @@
     return result;
   }
 
-  Token findDartDoc(Token token) {
+  Token? findDartDoc(Token token) {
     doPrint('findDartDoc(' '$token)');
     indent++;
     var result = super.findDartDoc(token);
@@ -2160,7 +2185,7 @@
     return result;
   }
 
-  int parseReferencesInSingleLineComments(Token token) {
+  int parseReferencesInSingleLineComments(Token? token) {
     doPrint('parseReferencesInSingleLineComments(' '$token)');
     indent++;
     var result = super.parseReferencesInSingleLineComments(token);
@@ -2196,9 +2221,9 @@
   void parseOneCommentReferenceRest(
       Token begin,
       int referenceOffset,
-      Token newKeyword,
-      Token prefix,
-      Token period,
+      Token? newKeyword,
+      Token? prefix,
+      Token? period,
       Token identifierOrOperator) {
     doPrint('parseOneCommentReferenceRest('
         '$begin, '
diff --git a/pkg/front_end/test/parser_test_parser_creator.dart b/pkg/front_end/test/parser_test_parser_creator.dart
index 002d238..0a69b8b 100644
--- a/pkg/front_end/test/parser_test_parser_creator.dart
+++ b/pkg/front_end/test/parser_test_parser_creator.dart
@@ -12,16 +12,23 @@
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
 import 'package:dart_style/dart_style.dart' show DartFormatter;
 
-StringSink out;
+import 'utils/io_utils.dart' show computeRepoDirUri;
 
 main(List<String> args) {
-  if (args.contains("--stdout")) {
-    out = stdout;
-  } else {
-    out = new StringBuffer();
-  }
-  File f = new File.fromUri(Platform.script
-      .resolve("../../_fe_analyzer_shared/lib/src/parser/parser_impl.dart"));
+  final Uri repoDir = computeRepoDirUri();
+  String generated = generateTestParser(repoDir);
+  new File.fromUri(computeTestParserUri(repoDir))
+      .writeAsStringSync(generated, flush: true);
+}
+
+Uri computeTestParserUri(Uri repoDir) {
+  return repoDir.resolve("pkg/front_end/test/parser_test_parser.dart");
+}
+
+String generateTestParser(Uri repoDir) {
+  StringBuffer out = new StringBuffer();
+  File f = new File.fromUri(repoDir
+      .resolve("pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart"));
   List<int> rawBytes = f.readAsBytesSync();
 
   Uint8List bytes = new Uint8List(rawBytes.length + 1);
@@ -46,17 +53,12 @@
 import 'package:_fe_analyzer_shared/src/parser/parser.dart' show Parser;
 import 'package:_fe_analyzer_shared/src/parser/token_stream_rewriter.dart';
 import 'package:_fe_analyzer_shared/src/parser/type_info.dart';
-import 'package:_fe_analyzer_shared/src/scanner/scanner.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
-import 'package:front_end/src/fasta/fasta_codes.dart';
+import 'package:front_end/src/fasta/fasta_codes.dart' as codes;
 
 // THIS FILE IS AUTO GENERATED BY 'test/parser_test_parser_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/test/parser_test_parser_creator.dart \
-      > pkg/front_end/test/parser_test_parser.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/test/parser_test_parser_creator.dart'
 
 class TestParser extends Parser {
   int indent = 0;
@@ -84,30 +86,27 @@
     if (trace) traceString = " (${createTrace()})";
     sb.writeln(("  " * indent) + s + traceString);
   }
+
 """);
 
-  ParserCreatorListener listener = new ParserCreatorListener();
+  ParserCreatorListener listener = new ParserCreatorListener(out);
   ClassMemberParser parser = new ClassMemberParser(listener);
   parser.parseUnit(firstToken);
 
   out.writeln("}");
 
-  if (out is StringBuffer) {
-    String text = new DartFormatter().format("$out");
-    if (args.isNotEmpty) {
-      new File(args.first).writeAsStringSync(text);
-    } else {
-      stdout.write(text);
-    }
-  }
+  return new DartFormatter().format("$out");
 }
 
 class ParserCreatorListener extends Listener {
+  final StringSink out;
   bool insideParserClass = false;
   String currentMethodName;
   List<String> parameters = <String>[];
   List<String> parametersNamed = <String>[];
 
+  ParserCreatorListener(this.out);
+
   void beginClassDeclaration(Token begin, Token abstractToken, Token name) {
     if (name.lexeme == "Parser") insideParserClass = true;
   }
diff --git a/pkg/front_end/test/utils/io_utils.dart b/pkg/front_end/test/utils/io_utils.dart
index 05be497..6c22a65 100644
--- a/pkg/front_end/test/utils/io_utils.dart
+++ b/pkg/front_end/test/utils/io_utils.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
-// @dart = 2.9
-
 import 'dart:io' show Directory, File, Platform, Process, ProcessResult;
 
 String computeRepoDir() {
diff --git a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
index 5c9509b..0d705a2 100644
--- a/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
+++ b/pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart
@@ -2,25 +2,31 @@
 // 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.
 
-import 'dart:io';
-import 'dart:typed_data';
+import 'dart:io' show File;
+import 'dart:typed_data' show Uint8List;
 
 import 'package:_fe_analyzer_shared/src/parser/parser.dart';
 import 'package:_fe_analyzer_shared/src/scanner/utf8_bytes_scanner.dart';
 import 'package:_fe_analyzer_shared/src/scanner/token.dart';
 import 'package:dart_style/dart_style.dart' show DartFormatter;
-
-late StringSink out;
+import '../../test/utils/io_utils.dart' show computeRepoDirUri;
 
 main(List<String> args) {
-  if (args.contains("--stdout")) {
-    out = stdout;
-  } else {
-    out = new StringBuffer();
-  }
+  final Uri repoDir = computeRepoDirUri();
+  String generated = generateAstHelper(repoDir);
+  new File.fromUri(computeAstHelperUri(repoDir))
+      .writeAsStringSync(generated, flush: true);
+}
 
-  File f = new File.fromUri(Platform.script
-      .resolve("../../../_fe_analyzer_shared/lib/src/parser/listener.dart"));
+Uri computeAstHelperUri(Uri repoDir) {
+  return repoDir.resolve(
+      "pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart");
+}
+
+String generateAstHelper(Uri repoDir) {
+  StringBuffer out = new StringBuffer();
+  File f = new File.fromUri(
+      repoDir.resolve("pkg/_fe_analyzer_shared/lib/src/parser/listener.dart"));
   List<int> rawBytes = f.readAsBytesSync();
 
   Uint8List bytes = new Uint8List(rawBytes.length + 1);
@@ -49,12 +55,8 @@
 
 // THIS FILE IS AUTO GENERATED BY
 // 'tool/_fasta/direct_parser_ast_helper_creator.dart'
-// Run e.g.
-/*
-   out/ReleaseX64/dart \
-     pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart \
-      > pkg/front_end/lib/src/fasta/util/direct_parser_ast_helper.dart
-*/
+// Run this command to update it:
+// 'dart pkg/front_end/tool/_fasta/direct_parser_ast_helper_creator.dart'
 
 abstract class DirectParserASTContent {
   final String what;
@@ -76,7 +78,7 @@
 
 """);
 
-  ParserCreatorListener listener = new ParserCreatorListener();
+  ParserCreatorListener listener = new ParserCreatorListener(out);
   ClassMemberParser parser = new ClassMemberParser(listener);
   parser.parseUnit(firstToken);
 
@@ -84,17 +86,11 @@
   out.writeln("");
   out.write(listener.newClasses.toString());
 
-  if (out is StringBuffer) {
-    String text = new DartFormatter().format("$out");
-    if (args.isNotEmpty) {
-      new File(args.first).writeAsStringSync(text);
-    } else {
-      stdout.write(text);
-    }
-  }
+  return new DartFormatter().format("$out");
 }
 
 class ParserCreatorListener extends Listener {
+  final StringSink out;
   bool insideListenerClass = false;
   String? currentMethodName;
   String? latestSeenParameterTypeToken;
@@ -102,6 +98,8 @@
   final List<Parameter> parameters = <Parameter>[];
   final StringBuffer newClasses = new StringBuffer();
 
+  ParserCreatorListener(this.out);
+
   void beginClassDeclaration(Token begin, Token? abstractToken, Token name) {
     if (name.lexeme == "Listener") insideListenerClass = true;
   }
diff --git a/pkg/front_end/tool/_fasta/generate_experimental_flags.dart b/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
index cd96105..f52aee6 100644
--- a/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
+++ b/pkg/front_end/tool/_fasta/generate_experimental_flags.dart
@@ -4,7 +4,7 @@
 
 // @dart=2.9
 
-import 'dart:io' show File, Platform;
+import 'dart:io' show File;
 
 import 'package:_fe_analyzer_shared/src/scanner/characters.dart'
     show $A, $MINUS, $a, $z;
@@ -15,35 +15,35 @@
 
 import 'package:yaml/yaml.dart' show YamlMap, loadYaml;
 
+import '../../test/utils/io_utils.dart' show computeRepoDirUri;
+
 main(List<String> arguments) {
-  new File.fromUri(computeCfeGeneratedFile())
-      .writeAsStringSync(generateCfeFile(), flush: true);
-  new File.fromUri(computeKernelGeneratedFile())
-      .writeAsStringSync(generateKernelFile(), flush: true);
+  final Uri repoDir = computeRepoDirUri();
+  new File.fromUri(computeCfeGeneratedFile(repoDir))
+      .writeAsStringSync(generateCfeFile(repoDir), flush: true);
+  new File.fromUri(computeKernelGeneratedFile(repoDir))
+      .writeAsStringSync(generateKernelFile(repoDir), flush: true);
 }
 
-Uri computeCfeGeneratedFile() {
-  return Platform.script
-      .resolve("../../lib/src/api_prototype/experimental_flags_generated.dart");
+Uri computeCfeGeneratedFile(Uri repoDir) {
+  return repoDir.resolve(
+      "pkg/front_end/lib/src/api_prototype/experimental_flags_generated.dart");
 }
 
-Uri computeKernelGeneratedFile() {
-  return Platform.script
-      .resolve("../../../kernel/lib/default_language_version.dart");
+Uri computeKernelGeneratedFile(Uri repoDir) {
+  return repoDir.resolve("pkg/kernel/lib/default_language_version.dart");
 }
 
-Uri computeYamlFile() {
-  return Platform.script
-      .resolve("../../../../tools/experimental_features.yaml");
+Uri computeYamlFile(Uri repoDir) {
+  return repoDir.resolve("tools/experimental_features.yaml");
 }
 
-Uri computeAllowListFile() {
-  return Platform.script
-      .resolve("../../../../sdk/lib/_internal/allowed_experiments.json");
+Uri computeAllowListFile(Uri repoDir) {
+  return repoDir.resolve("sdk/lib/_internal/allowed_experiments.json");
 }
 
-String generateKernelFile() {
-  Uri yamlFile = computeYamlFile();
+String generateKernelFile(Uri repoDir) {
+  Uri yamlFile = computeYamlFile(repoDir);
   Map<dynamic, dynamic> yaml =
       loadYaml(new File.fromUri(yamlFile).readAsStringSync());
 
@@ -76,8 +76,8 @@
   return new DartFormatter().format("$sb");
 }
 
-String generateCfeFile() {
-  Uri yamlFile = computeYamlFile();
+String generateCfeFile(Uri repoDir) {
+  Uri yamlFile = computeYamlFile(repoDir);
   Map<dynamic, dynamic> yaml =
       loadYaml(new File.fromUri(yamlFile).readAsStringSync());
 
@@ -237,7 +237,7 @@
   
 ''');
 
-  Uri allowListFile = computeAllowListFile();
+  Uri allowListFile = computeAllowListFile(repoDir);
   AllowedExperiments allowedExperiments = parseAllowedExperiments(
       new File.fromUri(allowListFile).readAsStringSync());
 
diff --git a/pkg/front_end/tool/_fasta/generate_experimental_flags_test.dart b/pkg/front_end/tool/_fasta/generate_experimental_flags_test.dart
deleted file mode 100644
index 8320f37..0000000
--- a/pkg/front_end/tool/_fasta/generate_experimental_flags_test.dart
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) 2018, 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.
-
-// @dart=2.9
-
-import "dart:io" show File, exitCode;
-
-import "generate_experimental_flags.dart"
-    show
-        computeCfeGeneratedFile,
-        computeKernelGeneratedFile,
-        generateCfeFile,
-        generateKernelFile;
-
-main() {
-  {
-    Uri generatedFile = computeCfeGeneratedFile();
-    String generated = generateCfeFile();
-    String actual = (new File.fromUri(generatedFile).readAsStringSync())
-        .replaceAll('\r\n', '\n');
-    check(generated, actual, generatedFile);
-  }
-  {
-    Uri generatedFile = computeKernelGeneratedFile();
-    String generated = generateKernelFile();
-    String actual = (new File.fromUri(generatedFile).readAsStringSync())
-        .replaceAll('\r\n', '\n');
-    check(generated, actual, generatedFile);
-  }
-}
-
-void check(String generated, String actual, Uri generatedFile) {
-  if (generated != actual) {
-    print("""
-------------------------
-
-The generated file
-  ${generatedFile.path}
-
-is out of date. To regenerate the file, run
-  dart pkg/front_end/tool/fasta.dart generate-experimental-flags
-
-------------------------
-""");
-    exitCode = 1;
-  }
-}
diff --git a/pkg/front_end/tool/_fasta/generate_messages.dart b/pkg/front_end/tool/_fasta/generate_messages.dart
index ba52246..8ddafe5 100644
--- a/pkg/front_end/tool/_fasta/generate_messages.dart
+++ b/pkg/front_end/tool/_fasta/generate_messages.dart
@@ -4,9 +4,7 @@
 
 // @dart=2.9
 
-import 'dart:io';
-
-import 'dart:isolate';
+import 'dart:io' show File, exitCode;
 
 import "package:_fe_analyzer_shared/src/messages/severity.dart"
     show severityEnumNames;
@@ -15,30 +13,31 @@
 
 import 'package:yaml/yaml.dart' show loadYaml;
 
-main(List<String> arguments) async {
-  var port = new ReceivePort();
-  Messages message = await generateMessagesFiles();
+import '../../test/utils/io_utils.dart' show computeRepoDirUri;
+
+main(List<String> arguments) {
+  final Uri repoDir = computeRepoDirUri();
+  Messages message = generateMessagesFiles(repoDir);
   if (message.sharedMessages.trim().isEmpty ||
       message.cfeMessages.trim().isEmpty) {
     print("Bailing because of errors: "
         "Refusing to overwrite with empty file!");
   } else {
-    await new File.fromUri(await computeSharedGeneratedFile())
-        .writeAsString(message.sharedMessages, flush: true);
-    await new File.fromUri(await computeCfeGeneratedFile())
-        .writeAsString(message.cfeMessages, flush: true);
+    new File.fromUri(computeSharedGeneratedFile(repoDir))
+        .writeAsStringSync(message.sharedMessages, flush: true);
+    new File.fromUri(computeCfeGeneratedFile(repoDir))
+        .writeAsStringSync(message.cfeMessages, flush: true);
   }
-  port.close();
 }
 
-Future<Uri> computeSharedGeneratedFile() {
-  return Isolate.resolvePackageUri(Uri.parse(
-      'package:_fe_analyzer_shared/src/messages/codes_generated.dart'));
+Uri computeSharedGeneratedFile(Uri repoDir) {
+  return repoDir
+      .resolve("pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart");
 }
 
-Future<Uri> computeCfeGeneratedFile() {
-  return Isolate.resolvePackageUri(
-      Uri.parse('package:front_end/src/fasta/fasta_codes_cfe_generated.dart'));
+Uri computeCfeGeneratedFile(Uri repoDir) {
+  return repoDir
+      .resolve("pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart");
 }
 
 class Messages {
@@ -48,10 +47,10 @@
   Messages(this.sharedMessages, this.cfeMessages);
 }
 
-Future<Messages> generateMessagesFiles() async {
-  Uri messagesFile = Platform.script.resolve("../../messages.yaml");
+Messages generateMessagesFiles(Uri repoDir) {
+  Uri messagesFile = repoDir.resolve("pkg/front_end/messages.yaml");
   Map<dynamic, dynamic> yaml =
-      loadYaml(await new File.fromUri(messagesFile).readAsStringSync());
+      loadYaml(new File.fromUri(messagesFile).readAsStringSync());
   StringBuffer sharedMessages = new StringBuffer();
   StringBuffer cfeMessages = new StringBuffer();
 
diff --git a/pkg/front_end/tool/_fasta/generate_messages_test.dart b/pkg/front_end/tool/_fasta/generate_messages_test.dart
deleted file mode 100644
index ccbff6a..0000000
--- a/pkg/front_end/tool/_fasta/generate_messages_test.dart
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) 2018, 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.
-
-// @dart=2.9
-
-import "dart:io" show File;
-
-import "package:async_helper/async_helper.dart" show asyncTest;
-
-import "package:expect/expect.dart" show Expect;
-
-import "generate_messages.dart";
-
-main() {
-  asyncTest(() async {
-    Messages messages = await generateMessagesFiles();
-
-    Uri generatedFile = await computeSharedGeneratedFile();
-    String sharedActual = (await new File.fromUri(generatedFile).readAsString())
-        .replaceAll('\r\n', '\n');
-    Expect.stringEquals(messages.sharedMessages, sharedActual,
-        "${generatedFile.path} is out of date");
-
-    Uri cfeGeneratedFile = await computeCfeGeneratedFile();
-    String cfeActual = (await new File.fromUri(cfeGeneratedFile).readAsString())
-        .replaceAll('\r\n', '\n');
-    Expect.stringEquals(messages.cfeMessages, cfeActual,
-        "${cfeGeneratedFile.path} is out of date");
-  });
-}
diff --git a/pkg/front_end/tool/smoke_test_quick.dart b/pkg/front_end/tool/smoke_test_quick.dart
index e942ef1..9c60324 100644
--- a/pkg/front_end/tool/smoke_test_quick.dart
+++ b/pkg/front_end/tool/smoke_test_quick.dart
@@ -29,7 +29,7 @@
       run("pkg/front_end/test/lint_suite.dart", ["--", "lint/front_end/..."]));
   futures.add(run("pkg/front_end/test/deps_git_test.dart", [], filter: false));
   futures.add(run(
-      "pkg/front_end/tool/_fasta/generate_experimental_flags_test.dart", [],
+      "pkg/front_end/test/generated_files_up_to_date_git_test.dart", [],
       filter: false));
   await Future.wait(futures);
   print("\n-----------------------\n");
diff --git a/pkg/kernel/lib/src/const_canonical_type.dart b/pkg/kernel/lib/src/const_canonical_type.dart
index b7edbd5..4c00536 100644
--- a/pkg/kernel/lib/src/const_canonical_type.dart
+++ b/pkg/kernel/lib/src/const_canonical_type.dart
@@ -12,7 +12,15 @@
 ///
 /// The algorithm is specified at
 /// https://github.com/dart-lang/language/blob/master/accepted/future-releases/nnbd/feature-specification.md#constant-instances
-DartType computeConstCanonicalType(DartType type, CoreTypes coreTypes,
+DartType? computeConstCanonicalType(DartType type, CoreTypes coreTypes,
+    {required bool isNonNullableByDefault}) {
+  // TODO(johnniwinther,dmitryas): Support returning `null` when the resulting
+  // type is the same as the input type.
+  return _computeConstCanonicalType(type, coreTypes,
+      isNonNullableByDefault: isNonNullableByDefault);
+}
+
+DartType _computeConstCanonicalType(DartType type, CoreTypes coreTypes,
     {required bool isNonNullableByDefault}) {
   // ignore: unnecessary_null_comparison
   assert(isNonNullableByDefault != null);
@@ -41,7 +49,7 @@
       isTypeWithoutNullabilityMarker(type,
           isNonNullableByDefault: isNonNullableByDefault)) {
     return new FutureOrType(
-        computeConstCanonicalType(type.typeArgument, coreTypes,
+        _computeConstCanonicalType(type.typeArgument, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault),
         Nullability.legacy);
   }
@@ -51,7 +59,7 @@
   // if S is R* then R?
   // else S?
   if (isNullableTypeConstructorApplication(type)) {
-    return computeConstCanonicalType(
+    return _computeConstCanonicalType(
             computeTypeWithoutNullabilityMarker(type,
                 isNonNullableByDefault: isNonNullableByDefault),
             coreTypes,
@@ -62,7 +70,7 @@
   // CONST_CANONICAL_TYPE(T*) = CONST_CANONICAL_TYPE(T)
   if (isLegacyTypeConstructorApplication(type,
       isNonNullableByDefault: isNonNullableByDefault)) {
-    return computeConstCanonicalType(
+    return _computeConstCanonicalType(
         computeTypeWithoutNullabilityMarker(type,
             isNonNullableByDefault: isNonNullableByDefault),
         coreTypes,
@@ -93,7 +101,7 @@
       typeArguments =
           new List<DartType>.of(type.typeArguments, growable: false);
       for (int i = 0; i < typeArguments.length; ++i) {
-        typeArguments[i] = computeConstCanonicalType(
+        typeArguments[i] = _computeConstCanonicalType(
             typeArguments[i], coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
       }
@@ -121,7 +129,7 @@
       substitution = freshTypeParameters.substitution;
       canonicalizedTypeParameters = freshTypeParameters.freshTypeParameters;
       for (TypeParameter parameter in canonicalizedTypeParameters) {
-        parameter.bound = computeConstCanonicalType(parameter.bound, coreTypes,
+        parameter.bound = _computeConstCanonicalType(parameter.bound, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
       }
       List<DartType> defaultTypes = calculateBoundsInternal(
@@ -139,7 +147,7 @@
       canonicalizedPositionalParameters =
           new List<DartType>.of(type.positionalParameters, growable: false);
       for (int i = 0; i < canonicalizedPositionalParameters.length; ++i) {
-        DartType canonicalized = computeConstCanonicalType(
+        DartType canonicalized = _computeConstCanonicalType(
             canonicalizedPositionalParameters[i], coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
         if (substitution != null) {
@@ -156,7 +164,7 @@
       canonicalizedNamedParameters =
           new List<NamedType>.of(type.namedParameters, growable: false);
       for (int i = 0; i < canonicalizedNamedParameters.length; ++i) {
-        DartType canonicalized = computeConstCanonicalType(
+        DartType canonicalized = _computeConstCanonicalType(
             canonicalizedNamedParameters[i].type, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
         if (substitution != null) {
@@ -168,7 +176,7 @@
       }
     }
 
-    DartType canonicalizedReturnType = computeConstCanonicalType(
+    DartType canonicalizedReturnType = _computeConstCanonicalType(
         type.returnType, coreTypes,
         isNonNullableByDefault: isNonNullableByDefault);
     if (substitution != null) {
@@ -189,7 +197,7 @@
         canonicalizedTypeArguments =
             new List<DartType>.of(typedefType.typeArguments, growable: false);
         for (int i = 0; i < canonicalizedTypeArguments.length; ++i) {
-          canonicalizedTypeArguments[i] = computeConstCanonicalType(
+          canonicalizedTypeArguments[i] = _computeConstCanonicalType(
               canonicalizedTypeArguments[i], coreTypes,
               isNonNullableByDefault: isNonNullableByDefault);
         }
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index 9e6fae8..6add21d 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -857,6 +857,26 @@
   }
 }
 
+static bool CanBePairOfImmediateOperands(const dart::Object& constant,
+                                         compiler::Operand* low,
+                                         compiler::Operand* high) {
+  int64_t imm;
+  if (!compiler::HasIntegerValue(constant, &imm)) {
+    return false;
+  }
+  return compiler::Operand::CanHold(Utils::Low32Bits(imm), low) &&
+         compiler::Operand::CanHold(Utils::High32Bits(imm), high);
+}
+
+static bool CanBePairOfImmediateOperands(Value* value,
+                                         compiler::Operand* low,
+                                         compiler::Operand* high) {
+  if (!value->BindsToConstant()) {
+    return false;
+  }
+  return CanBePairOfImmediateOperands(value->BoundConstant(), low, high);
+}
+
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
@@ -871,13 +891,24 @@
     return locs;
   }
   if (operation_cid() == kMintCid) {
+    compiler::Operand o;
     const intptr_t kNumTemps = 0;
     LocationSummary* locs = new (zone)
         LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    locs->set_in(0, Location::Pair(Location::RequiresRegister(),
-                                   Location::RequiresRegister()));
-    locs->set_in(1, Location::Pair(Location::RequiresRegister(),
-                                   Location::RequiresRegister()));
+    if (CanBePairOfImmediateOperands(left(), &o, &o)) {
+      locs->set_in(0, Location::Constant(left()->definition()->AsConstant()));
+      locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+    } else if (CanBePairOfImmediateOperands(right(), &o, &o)) {
+      locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+      locs->set_in(1, Location::Constant(right()->definition()->AsConstant()));
+    } else {
+      locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+      locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+    }
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
@@ -993,17 +1024,31 @@
                                            LocationSummary* locs,
                                            Token::Kind kind) {
   ASSERT(Token::IsEqualityOperator(kind));
-  PairLocation* left_pair = locs->in(0).AsPairLocation();
+  PairLocation* left_pair;
+  compiler::Operand right_lo, right_hi;
+  if (locs->in(0).IsConstant()) {
+    const bool ok = CanBePairOfImmediateOperands(locs->in(0).constant(),
+                                                 &right_lo, &right_hi);
+    RELEASE_ASSERT(ok);
+    left_pair = locs->in(1).AsPairLocation();
+  } else if (locs->in(1).IsConstant()) {
+    const bool ok = CanBePairOfImmediateOperands(locs->in(1).constant(),
+                                                 &right_lo, &right_hi);
+    RELEASE_ASSERT(ok);
+    left_pair = locs->in(0).AsPairLocation();
+  } else {
+    left_pair = locs->in(0).AsPairLocation();
+    PairLocation* right_pair = locs->in(1).AsPairLocation();
+    right_lo = compiler::Operand(right_pair->At(0).reg());
+    right_hi = compiler::Operand(right_pair->At(1).reg());
+  }
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
-  PairLocation* right_pair = locs->in(1).AsPairLocation();
-  Register right_lo = right_pair->At(0).reg();
-  Register right_hi = right_pair->At(1).reg();
 
   // Compare lower.
-  __ cmp(left_lo, compiler::Operand(right_lo));
+  __ cmp(left_lo, right_lo);
   // Compare upper if lower is equal.
-  __ cmp(left_hi, compiler::Operand(right_hi), EQ);
+  __ cmp(left_hi, right_hi, EQ);
   return TokenKindToIntCondition(kind);
 }
 
@@ -1011,29 +1056,45 @@
                                              LocationSummary* locs,
                                              Token::Kind kind,
                                              BranchLabels labels) {
-  PairLocation* left_pair = locs->in(0).AsPairLocation();
+  PairLocation* left_pair;
+  compiler::Operand right_lo, right_hi;
+  Condition true_condition = TokenKindToIntCondition(kind);
+  if (locs->in(0).IsConstant()) {
+    const bool ok = CanBePairOfImmediateOperands(locs->in(0).constant(),
+                                                 &right_lo, &right_hi);
+    RELEASE_ASSERT(ok);
+    left_pair = locs->in(1).AsPairLocation();
+    true_condition = FlipCondition(true_condition);
+  } else if (locs->in(1).IsConstant()) {
+    const bool ok = CanBePairOfImmediateOperands(locs->in(1).constant(),
+                                                 &right_lo, &right_hi);
+    RELEASE_ASSERT(ok);
+    left_pair = locs->in(0).AsPairLocation();
+  } else {
+    left_pair = locs->in(0).AsPairLocation();
+    PairLocation* right_pair = locs->in(1).AsPairLocation();
+    right_lo = compiler::Operand(right_pair->At(0).reg());
+    right_hi = compiler::Operand(right_pair->At(1).reg());
+  }
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
-  PairLocation* right_pair = locs->in(1).AsPairLocation();
-  Register right_lo = right_pair->At(0).reg();
-  Register right_hi = right_pair->At(1).reg();
 
   // 64-bit comparison.
   Condition hi_cond, lo_cond;
-  switch (kind) {
-    case Token::kLT:
+  switch (true_condition) {
+    case LT:
       hi_cond = LT;
       lo_cond = CC;
       break;
-    case Token::kGT:
+    case GT:
       hi_cond = GT;
       lo_cond = HI;
       break;
-    case Token::kLTE:
+    case LE:
       hi_cond = LT;
       lo_cond = LS;
       break;
-    case Token::kGTE:
+    case GE:
       hi_cond = GT;
       lo_cond = CS;
       break;
@@ -1042,12 +1103,12 @@
       hi_cond = lo_cond = VS;
   }
   // Compare upper halves first.
-  __ cmp(left_hi, compiler::Operand(right_hi));
+  __ cmp(left_hi, right_hi);
   __ b(labels.true_label, hi_cond);
   __ b(labels.false_label, FlipCondition(hi_cond));
 
   // If higher words are equal, compare lower words.
-  __ cmp(left_lo, compiler::Operand(right_lo));
+  __ cmp(left_lo, right_lo);
   return lo_cond;
 }
 
@@ -1233,13 +1294,24 @@
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operation_cid() == kMintCid) {
+    compiler::Operand o;
     const intptr_t kNumTemps = 0;
     LocationSummary* locs = new (zone)
         LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    locs->set_in(0, Location::Pair(Location::RequiresRegister(),
-                                   Location::RequiresRegister()));
-    locs->set_in(1, Location::Pair(Location::RequiresRegister(),
-                                   Location::RequiresRegister()));
+    if (CanBePairOfImmediateOperands(left(), &o, &o)) {
+      locs->set_in(0, Location::Constant(left()->definition()->AsConstant()));
+      locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+    } else if (CanBePairOfImmediateOperands(right(), &o, &o)) {
+      locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+      locs->set_in(1, Location::Constant(right()->definition()->AsConstant()));
+    } else {
+      locs->set_in(0, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+      locs->set_in(1, Location::Pair(Location::RequiresRegister(),
+                                     Location::RequiresRegister()));
+    }
     locs->set_out(0, Location::RequiresRegister());
     return locs;
   }
@@ -6444,18 +6516,6 @@
   }
 }
 
-static bool CanBePairOfImmediateOperands(Value* value,
-                                         compiler::Operand* low,
-                                         compiler::Operand* high) {
-  int64_t imm;
-  if (value->BindsToConstant() &&
-      compiler::HasIntegerValue(value->BoundConstant(), &imm)) {
-    return compiler::Operand::CanHold(Utils::Low32Bits(imm), low) &&
-      compiler::Operand::CanHold(Utils::High32Bits(imm), high);
-  }
-  return false;
-}
-
 LocationSummary* BinaryInt64OpInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
   const intptr_t kNumInputs = 2;
@@ -6495,7 +6555,8 @@
 
   compiler::Operand right_lo, right_hi;
   if (locs()->in(1).IsConstant()) {
-    const bool ok = CanBePairOfImmediateOperands(right(), &right_lo, &right_hi);
+    const bool ok = CanBePairOfImmediateOperands(locs()->in(1).constant(),
+                                                 &right_lo, &right_hi);
     RELEASE_ASSERT(ok);
   } else {
     PairLocation* right_pair = locs()->in(1).AsPairLocation();
diff --git a/runtime/vm/compiler/stub_code_compiler.h b/runtime/vm/compiler/stub_code_compiler.h
index 7c5c243..7b7eb71 100644
--- a/runtime/vm/compiler/stub_code_compiler.h
+++ b/runtime/vm/compiler/stub_code_compiler.h
@@ -53,8 +53,8 @@
 #if !defined(TARGET_ARCH_IA32)
   static void GenerateBuildMethodExtractorStub(
       Assembler* assembler,
-      const Object& closure_allocation_stub,
-      const Object& context_allocation_stub);
+      const Code& closure_allocation_stub,
+      const Code& context_allocation_stub);
 #endif
 
   static void EnsureIsNewOrRemembered(Assembler* assembler,
diff --git a/runtime/vm/compiler/stub_code_compiler_arm.cc b/runtime/vm/compiler/stub_code_compiler_arm.cc
index 0045e4e..9f15dbb 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm.cc
@@ -223,8 +223,8 @@
 // SP+0: The object from which we are tearing a method off.
 void StubCodeCompiler::GenerateBuildMethodExtractorStub(
     Assembler* assembler,
-    const Object& closure_allocation_stub,
-    const Object& context_allocation_stub) {
+    const Code& closure_allocation_stub,
+    const Code& context_allocation_stub) {
   const intptr_t kReceiverOffset = target::frame_layout.param_end_from_fp + 1;
 
   __ EnterStubFrame();
diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc
index 428b5df..b2420bd 100644
--- a/runtime/vm/compiler/stub_code_compiler_arm64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc
@@ -457,8 +457,8 @@
 // R4: The type_arguments_field_offset (or 0)
 void StubCodeCompiler::GenerateBuildMethodExtractorStub(
     Assembler* assembler,
-    const Object& closure_allocation_stub,
-    const Object& context_allocation_stub) {
+    const Code& closure_allocation_stub,
+    const Code& context_allocation_stub) {
   const intptr_t kReceiverOffset = target::frame_layout.param_end_from_fp + 1;
 
   __ EnterStubFrame();
diff --git a/runtime/vm/compiler/stub_code_compiler_x64.cc b/runtime/vm/compiler/stub_code_compiler_x64.cc
index 6b0782f..138d7ce 100644
--- a/runtime/vm/compiler/stub_code_compiler_x64.cc
+++ b/runtime/vm/compiler/stub_code_compiler_x64.cc
@@ -400,8 +400,8 @@
 // RDX: The type_arguments_field_offset (or 0)
 void StubCodeCompiler::GenerateBuildMethodExtractorStub(
     Assembler* assembler,
-    const Object& closure_allocation_stub,
-    const Object& context_allocation_stub) {
+    const Code& closure_allocation_stub,
+    const Code& context_allocation_stub) {
   const intptr_t kReceiverOffsetInWords =
       target::frame_layout.param_end_from_fp + 1;
 
diff --git a/runtime/vm/native_api_impl.cc b/runtime/vm/native_api_impl.cc
index e472564..8914904 100644
--- a/runtime/vm/native_api_impl.cc
+++ b/runtime/vm/native_api_impl.cc
@@ -233,8 +233,6 @@
 };
 
 DART_EXPORT void* Dart_ExecuteInternalCommand(const char* command, void* arg) {
-  if (!FLAG_enable_testing_pragmas) return nullptr;
-
   if (strcmp(command, "gc-on-nth-allocation") == 0) {
     TransitionNativeToVM _(Thread::Current());
     intptr_t argument = reinterpret_cast<intptr_t>(arg);
diff --git a/runtime/vm/stub_code.cc b/runtime/vm/stub_code.cc
index 3adc5d9..78a3355 100644
--- a/runtime/vm/stub_code.cc
+++ b/runtime/vm/stub_code.cc
@@ -306,11 +306,10 @@
   auto Z = thread->zone();
   auto object_store = thread->isolate_group()->object_store();
 
-  const auto& closure_class =
-      Class::ZoneHandle(Z, object_store->closure_class());
   const auto& closure_allocation_stub =
-      Code::ZoneHandle(Z, StubCode::GetAllocationStubForClass(closure_class));
-  const auto& context_allocation_stub = StubCode::AllocateContext();
+      Code::ZoneHandle(Z, object_store->allocate_closure_stub());
+  const auto& context_allocation_stub =
+      Code::ZoneHandle(Z, object_store->allocate_context_stub());
 
   compiler::ObjectPoolBuilder object_pool_builder;
   compiler::Assembler assembler(pool != nullptr ? pool : &object_pool_builder);
diff --git a/tests/ffi/function_callbacks_many_test.dart b/tests/ffi/function_callbacks_many_test.dart
index c8fb519..2cd03b2 100644
--- a/tests/ffi/function_callbacks_many_test.dart
+++ b/tests/ffi/function_callbacks_many_test.dart
@@ -4,14 +4,13 @@
 //
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi/function_callbacks_test.dart b/tests/ffi/function_callbacks_test.dart
index e9a853c..a2caaeb 100644
--- a/tests/ffi/function_callbacks_test.dart
+++ b/tests/ffi/function_callbacks_test.dart
@@ -4,16 +4,15 @@
 
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // VMOptions=--use-bare-instructions=false
-// VMOptions=--enable-testing-pragmas --dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
+// VMOptions=--dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi/function_callbacks_very_many_test.dart b/tests/ffi/function_callbacks_very_many_test.dart
index 383b482..3180e89 100644
--- a/tests/ffi/function_callbacks_very_many_test.dart
+++ b/tests/ffi/function_callbacks_very_many_test.dart
@@ -5,14 +5,13 @@
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
 // VMOptions=--deterministic --optimization-counter-threshold=10
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi/regress_jump_to_frame_test.dart b/tests/ffi/regress_jump_to_frame_test.dart
index f47800b..c834253 100644
--- a/tests/ffi/regress_jump_to_frame_test.dart
+++ b/tests/ffi/regress_jump_to_frame_test.dart
@@ -4,7 +4,7 @@
 
 // Check that JumpToFrame does not use LR clobbered by slow path of
 // TransitionNativeToGenerated.
-// VMOptions=--use-slow-path --enable-testing-pragmas
+// VMOptions=--use-slow-path
 
 import 'dart:ffi';
 
diff --git a/tests/ffi/vmspecific_function_callbacks_test.dart b/tests/ffi/vmspecific_function_callbacks_test.dart
index 510193c..f35ae18 100644
--- a/tests/ffi/vmspecific_function_callbacks_test.dart
+++ b/tests/ffi/vmspecific_function_callbacks_test.dart
@@ -2,19 +2,18 @@
 // 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.
 
-// VMOptions=--enable-testing-pragmas --enable-isolate-groups --experimental-enable-isolate-groups-jit
-// VMOptions=--enable-testing-pragmas --no-enable-isolate-groups
 //
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--enable-isolate-groups --experimental-enable-isolate-groups-jit
+// VMOptions=--no-enable-isolate-groups
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi/vmspecific_function_gc_test.dart b/tests/ffi/vmspecific_function_gc_test.dart
index e104bcc..febf135 100644
--- a/tests/ffi/vmspecific_function_gc_test.dart
+++ b/tests/ffi/vmspecific_function_gc_test.dart
@@ -2,12 +2,12 @@
 // 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.
 //
-// VMOptions=--deterministic --optimization-counter-threshold=500 --enable-testing-pragmas
-// VMOptions=--deterministic --optimization-counter-threshold=-1 --enable-testing-pragmas
-// VMOptions=--deterministic --optimization-counter-threshold=500 --enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--deterministic --optimization-counter-threshold=-1 --enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--enable-testing-pragmas --no-dual-map-code --write-protect-code --stacktrace-every=100
+// VMOptions=--deterministic --optimization-counter-threshold=500
+// VMOptions=--deterministic --optimization-counter-threshold=-1
+// VMOptions=--deterministic --optimization-counter-threshold=500 --no-dual-map-code --write-protect-code
+// VMOptions=--deterministic --optimization-counter-threshold=-1 --no-dual-map-code --write-protect-code
+// VMOptions=--no-dual-map-code --write-protect-code
+// VMOptions=--no-dual-map-code --write-protect-code --stacktrace-every=100
 //
 // Dart test program for stress-testing boxing and GC in return paths from FFI
 // trampolines.
diff --git a/tests/ffi/vmspecific_handle_test.dart b/tests/ffi/vmspecific_handle_test.dart
index dcb5e38..00ec530 100644
--- a/tests/ffi/vmspecific_handle_test.dart
+++ b/tests/ffi/vmspecific_handle_test.dart
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 //
 // SharedObjects=ffi_test_functions
-// VMOptions=--enable-testing-pragmas
 
 import 'dart:ffi';
 
diff --git a/tests/ffi/vmspecific_regress_37511_callbacks_test.dart b/tests/ffi/vmspecific_regress_37511_callbacks_test.dart
index 0153560..2425c5d 100644
--- a/tests/ffi/vmspecific_regress_37511_callbacks_test.dart
+++ b/tests/ffi/vmspecific_regress_37511_callbacks_test.dart
@@ -4,7 +4,7 @@
 //
 // Dart test program for testing dart:ffi struct pointers.
 //
-// VMOptions=--deterministic --enable-testing-pragmas
+// VMOptions=--deterministic
 //
 // SharedObjects=ffi_test_functions
 //
diff --git a/tests/ffi/vmspecific_regress_37511_test.dart b/tests/ffi/vmspecific_regress_37511_test.dart
index 6d857e5..e15bd8b 100644
--- a/tests/ffi/vmspecific_regress_37511_test.dart
+++ b/tests/ffi/vmspecific_regress_37511_test.dart
@@ -4,7 +4,7 @@
 //
 // Dart test program for testing dart:ffi struct pointers.
 //
-// VMOptions=--deterministic --enable-testing-pragmas
+// VMOptions=--deterministic
 //
 // SharedObjects=ffi_test_functions
 
diff --git a/tests/ffi_2/function_callbacks_many_test.dart b/tests/ffi_2/function_callbacks_many_test.dart
index 5f1a273..f34b4ae 100644
--- a/tests/ffi_2/function_callbacks_many_test.dart
+++ b/tests/ffi_2/function_callbacks_many_test.dart
@@ -4,14 +4,13 @@
 //
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
 // @dart = 2.9
diff --git a/tests/ffi_2/function_callbacks_test.dart b/tests/ffi_2/function_callbacks_test.dart
index 9e0ac35..cb1b055 100644
--- a/tests/ffi_2/function_callbacks_test.dart
+++ b/tests/ffi_2/function_callbacks_test.dart
@@ -6,16 +6,15 @@
 
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // VMOptions=--use-bare-instructions=false
-// VMOptions=--enable-testing-pragmas --dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
+// VMOptions=--dwarf_stack_traces --no-retain_function_objects --no-retain_code_objects
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi_2/function_callbacks_very_many_test.dart b/tests/ffi_2/function_callbacks_very_many_test.dart
index d177728..957e13b 100644
--- a/tests/ffi_2/function_callbacks_very_many_test.dart
+++ b/tests/ffi_2/function_callbacks_very_many_test.dart
@@ -7,14 +7,13 @@
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
 // VMOptions=--deterministic --optimization-counter-threshold=10
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
 
 import 'dart:ffi';
diff --git a/tests/ffi_2/regress_jump_to_frame_test.dart b/tests/ffi_2/regress_jump_to_frame_test.dart
index 7fae296a..7ff59f8 100644
--- a/tests/ffi_2/regress_jump_to_frame_test.dart
+++ b/tests/ffi_2/regress_jump_to_frame_test.dart
@@ -6,7 +6,7 @@
 
 // Check that JumpToFrame does not use LR clobbered by slow path of
 // TransitionNativeToGenerated.
-// VMOptions=--use-slow-path --enable-testing-pragmas
+// VMOptions=--use-slow-path
 
 import 'dart:ffi';
 
diff --git a/tests/ffi_2/vmspecific_function_callbacks_test.dart b/tests/ffi_2/vmspecific_function_callbacks_test.dart
index 6f88079..6d9311f 100644
--- a/tests/ffi_2/vmspecific_function_callbacks_test.dart
+++ b/tests/ffi_2/vmspecific_function_callbacks_test.dart
@@ -4,20 +4,18 @@
 
 // @dart = 2.9
 
-// VMOptions=--enable-testing-pragmas --enable-isolate-groups --experimental-enable-isolate-groups-jit
-// VMOptions=--enable-testing-pragmas --no-enable-isolate-groups
-//
 // Dart test program for testing dart:ffi function pointers with callbacks.
 //
-// VMOptions=--enable-testing-pragmas
-// VMOptions=--enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas
-// VMOptions=--use-slow-path --enable-testing-pragmas --stacktrace-every=100
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code
-// VMOptions=--use-slow-path --enable-testing-pragmas --write-protect-code --no-dual-map-code --stacktrace-every=100
 // SharedObjects=ffi_test_functions
+// VMOptions=--enable-isolate-groups --experimental-enable-isolate-groups-jit
+// VMOptions=--no-enable-isolate-groups
+// VMOptions=--stacktrace-every=100
+// VMOptions=--use-slow-path
+// VMOptions=--use-slow-path --stacktrace-every=100
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code
+// VMOptions=--use-slow-path --write-protect-code --no-dual-map-code --stacktrace-every=100
+// VMOptions=--write-protect-code --no-dual-map-code
+// VMOptions=--write-protect-code --no-dual-map-code --stacktrace-every=100
 
 import 'dart:ffi';
 
diff --git a/tests/ffi_2/vmspecific_function_gc_test.dart b/tests/ffi_2/vmspecific_function_gc_test.dart
index c15e9d5..462601b 100644
--- a/tests/ffi_2/vmspecific_function_gc_test.dart
+++ b/tests/ffi_2/vmspecific_function_gc_test.dart
@@ -2,12 +2,12 @@
 // 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.
 //
-// VMOptions=--deterministic --optimization-counter-threshold=500 --enable-testing-pragmas
-// VMOptions=--deterministic --optimization-counter-threshold=-1 --enable-testing-pragmas
-// VMOptions=--deterministic --optimization-counter-threshold=500 --enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--deterministic --optimization-counter-threshold=-1 --enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--enable-testing-pragmas --no-dual-map-code --write-protect-code
-// VMOptions=--enable-testing-pragmas --no-dual-map-code --write-protect-code --stacktrace-every=100
+// VMOptions=--deterministic --optimization-counter-threshold=500
+// VMOptions=--deterministic --optimization-counter-threshold=-1
+// VMOptions=--deterministic --optimization-counter-threshold=500 --no-dual-map-code --write-protect-code
+// VMOptions=--deterministic --optimization-counter-threshold=-1 --no-dual-map-code --write-protect-code
+// VMOptions=--no-dual-map-code --write-protect-code
+// VMOptions=--no-dual-map-code --write-protect-code --stacktrace-every=100
 //
 // Dart test program for stress-testing boxing and GC in return paths from FFI
 // trampolines.
diff --git a/tests/ffi_2/vmspecific_handle_test.dart b/tests/ffi_2/vmspecific_handle_test.dart
index 814d547..d228aa1 100644
--- a/tests/ffi_2/vmspecific_handle_test.dart
+++ b/tests/ffi_2/vmspecific_handle_test.dart
@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 //
 // SharedObjects=ffi_test_functions
-// VMOptions=--enable-testing-pragmas
 
 // @dart = 2.9
 
diff --git a/tests/ffi_2/vmspecific_regress_37511_callbacks_test.dart b/tests/ffi_2/vmspecific_regress_37511_callbacks_test.dart
index 1615b56..3e67081 100644
--- a/tests/ffi_2/vmspecific_regress_37511_callbacks_test.dart
+++ b/tests/ffi_2/vmspecific_regress_37511_callbacks_test.dart
@@ -4,7 +4,7 @@
 //
 // Dart test program for testing dart:ffi struct pointers.
 //
-// VMOptions=--deterministic --enable-testing-pragmas
+// VMOptions=--deterministic
 //
 // SharedObjects=ffi_test_functions
 //
diff --git a/tests/ffi_2/vmspecific_regress_37511_test.dart b/tests/ffi_2/vmspecific_regress_37511_test.dart
index 9b60cb5..290c4e8 100644
--- a/tests/ffi_2/vmspecific_regress_37511_test.dart
+++ b/tests/ffi_2/vmspecific_regress_37511_test.dart
@@ -4,7 +4,7 @@
 //
 // Dart test program for testing dart:ffi struct pointers.
 //
-// VMOptions=--deterministic --enable-testing-pragmas
+// VMOptions=--deterministic
 //
 // SharedObjects=ffi_test_functions
 
diff --git a/tools/VERSION b/tools/VERSION
index 7e30d67..1c363e3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 136
+PRERELEASE 137
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/utils/application_snapshot.gni b/utils/application_snapshot.gni
index 51d2b147..7ecdf28 100644
--- a/utils/application_snapshot.gni
+++ b/utils/application_snapshot.gni
@@ -145,7 +145,7 @@
     dfe = "$_dart_root/pkg/vm/bin/kernel_service.dart"
 
     abs_depfile = rebase_path(depfile)
-    abs_output = rebase_path(output)
+    abs_output = rebase_path(output, root_build_dir)
 
     vm_args = [
                 "--deterministic",