diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5f02905..1ab41b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,30 @@
 
   This brings the implementation behavior in line with the spec.
 
+- Initializer expressions on implicitly typed condition variables can now
+  contribute to type promotion.  For example, this program no longer produces a
+  compile-time error:
+
+  ```dart
+  f(int? i) {
+    var iIsNull = i == null;
+    if (!iIsNull) {
+      print(i + 1); // OK, because `i` is known to be non-null
+    }
+  }
+  ```
+
+  Previously, the above program had a compile-time error because type promotion
+  due to a bug ([#1785][]) which prevented the initializer expression (`i ==
+  null`) from being accounted for when the variable in question (`iIsNull`)
+  lacked an explicit type.
+
+  To avoid causing problems for packages that are intended to work with older
+  versions of Dart, the fix only takes effect when the "constructor tearoffs"
+  language feature is enabled.
+
+[#1785]: https://github.com/dart-lang/language/issues/1785
+
 ### Tools
 
 #### Dart command line
diff --git a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
index b050ba3..55b94a9 100644
--- a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
@@ -368,8 +368,11 @@
 abstract class FlowAnalysis<Node extends Object, Statement extends Node,
     Expression extends Object, Variable extends Object, Type extends Object> {
   factory FlowAnalysis(TypeOperations<Variable, Type> typeOperations,
-      AssignedVariables<Node, Variable> assignedVariables) {
-    return new _FlowAnalysisImpl(typeOperations, assignedVariables);
+      AssignedVariables<Node, Variable> assignedVariables,
+      {required bool respectImplicitlyTypedVarInitializers}) {
+    return new _FlowAnalysisImpl(typeOperations, assignedVariables,
+        respectImplicitlyTypedVarInitializers:
+            respectImplicitlyTypedVarInitializers);
   }
 
   factory FlowAnalysis.legacy(TypeOperations<Variable, Type> typeOperations,
@@ -634,7 +637,9 @@
   /// Call this method after visiting the initializer of a variable declaration.
   void initialize(
       Variable variable, Type initializerType, Expression initializerExpression,
-      {required bool isFinal, required bool isLate});
+      {required bool isFinal,
+      required bool isLate,
+      required bool isImplicitlyTyped});
 
   /// Return whether the [variable] is definitely assigned in the current state.
   bool isAssigned(Variable variable);
@@ -724,11 +729,6 @@
   void parenthesizedExpression(
       Expression outerExpression, Expression innerExpression);
 
-  /// Attempt to promote [variable] to [type].  The client may use this to
-  /// ensure that a variable declaration of the form `var x = expr;` promotes
-  /// `x` to type `X&T` in the circumstance where the type of `expr` is `X&T`.
-  void promote(Variable variable, Type type);
-
   /// Retrieves the type that the [variable] is promoted to, if the [variable]
   /// is currently promoted.  Otherwise returns `null`.
   Type? promotedType(Variable variable);
@@ -986,10 +986,13 @@
   bool _exceptionOccurred = false;
 
   factory FlowAnalysisDebug(TypeOperations<Variable, Type> typeOperations,
-      AssignedVariables<Node, Variable> assignedVariables) {
+      AssignedVariables<Node, Variable> assignedVariables,
+      {required bool respectImplicitlyTypedVarInitializers}) {
     print('FlowAnalysisDebug()');
-    return new FlowAnalysisDebug._(
-        new _FlowAnalysisImpl(typeOperations, assignedVariables));
+    return new FlowAnalysisDebug._(new _FlowAnalysisImpl(
+        typeOperations, assignedVariables,
+        respectImplicitlyTypedVarInitializers:
+            respectImplicitlyTypedVarInitializers));
   }
 
   factory FlowAnalysisDebug.legacy(
@@ -1225,13 +1228,18 @@
   @override
   void initialize(
       Variable variable, Type initializerType, Expression initializerExpression,
-      {required bool isFinal, required bool isLate}) {
+      {required bool isFinal,
+      required bool isLate,
+      required bool isImplicitlyTyped}) {
     _wrap(
         'initialize($variable, $initializerType, $initializerExpression, '
-        'isFinal: $isFinal, isLate: $isLate)',
+        'isFinal: $isFinal, isLate: $isLate, '
+        'isImplicitlyTyped: $isImplicitlyTyped)',
         () => _wrapped.initialize(
             variable, initializerType, initializerExpression,
-            isFinal: isFinal, isLate: isLate));
+            isFinal: isFinal,
+            isLate: isLate,
+            isImplicitlyTyped: isImplicitlyTyped));
   }
 
   @override
@@ -1341,11 +1349,6 @@
   }
 
   @override
-  void promote(Variable variable, Type type) {
-    _wrap('promote($variable, $type', () => _wrapped.promote(variable, type));
-  }
-
-  @override
   Type? promotedType(Variable variable) {
     return _wrap(
         'promotedType($variable)', () => _wrapped.promotedType(variable),
@@ -2059,12 +2062,14 @@
       Variable variable,
       Type writtenType,
       SsaNode<Variable, Type> newSsaNode,
-      TypeOperations<Variable, Type> typeOperations) {
+      TypeOperations<Variable, Type> typeOperations,
+      {bool promoteToTypeOfInterest = true}) {
     VariableModel<Variable, Type>? infoForVar = variableInfo[variable];
     if (infoForVar == null) return this;
 
     VariableModel<Variable, Type> newInfoForVar = infoForVar.write(
-        nonPromotionReason, variable, writtenType, typeOperations, newSsaNode);
+        nonPromotionReason, variable, writtenType, typeOperations, newSsaNode,
+        promoteToTypeOfInterest: promoteToTypeOfInterest);
     if (identical(newInfoForVar, infoForVar)) return this;
 
     return _updateVariableInfo(new VariableReference(variable), newInfoForVar);
@@ -2663,6 +2668,9 @@
   /// Return `true` if the [leftType] is a subtype of the [rightType].
   bool isSubtypeOf(Type leftType, Type rightType);
 
+  /// Returns `true` if [type] is a reference to a type parameter.
+  bool isTypeParameterType(Type type);
+
   /// Returns the non-null promoted version of [type].
   ///
   /// Note that some types don't have a non-nullable version (e.g.
@@ -2819,7 +2827,8 @@
       Variable variable,
       Type writtenType,
       TypeOperations<Variable, Type> typeOperations,
-      SsaNode<Variable, Type> newSsaNode) {
+      SsaNode<Variable, Type> newSsaNode,
+      {required bool promoteToTypeOfInterest}) {
     if (writeCaptured) {
       return new VariableModel<Variable, Type>(
           promotedTypes: promotedTypes,
@@ -2834,8 +2843,10 @@
     List<Type>? newPromotedTypes = demotionResult.promotedTypes;
 
     Type declaredType = typeOperations.variableType(variable);
-    newPromotedTypes = _tryPromoteToTypeOfInterest(
-        typeOperations, declaredType, newPromotedTypes, writtenType);
+    if (promoteToTypeOfInterest) {
+      newPromotedTypes = _tryPromoteToTypeOfInterest(
+          typeOperations, declaredType, newPromotedTypes, writtenType);
+    }
     // TODO(paulberry): remove demotions from demotionResult.nonPromotionHistory
     // that are no longer in effect due to re-promotion.
     if (identical(promotedTypes, newPromotedTypes) && assigned) {
@@ -3449,7 +3460,15 @@
 
   final AssignedVariables<Node, Variable> _assignedVariables;
 
-  _FlowAnalysisImpl(this.typeOperations, this._assignedVariables);
+  /// Indicates whether initializers of implicitly typed variables should be
+  /// accounted for by SSA analysis.  (In an ideal world, they always would be,
+  /// but due to https://github.com/dart-lang/language/issues/1785, they weren't
+  /// always, and we need to be able to replicate the old behavior when
+  /// analyzing old language versions).
+  final bool respectImplicitlyTypedVarInitializers;
+
+  _FlowAnalysisImpl(this.typeOperations, this._assignedVariables,
+      {required this.respectImplicitlyTypedVarInitializers});
 
   @override
   bool get isReachable => _current.reachable.overallReachable;
@@ -3798,21 +3817,38 @@
   @override
   void initialize(
       Variable variable, Type initializerType, Expression initializerExpression,
-      {required bool isFinal, required bool isLate}) {
-    ExpressionInfo<Variable, Type>? expressionInfo =
-        _getExpressionInfo(initializerExpression);
-    SsaNode<Variable, Type> newSsaNode = new SsaNode<Variable, Type>(isLate
-        ? null
-        : expressionInfo is _TrivialExpressionInfo
-            ? null
-            : expressionInfo);
-    if (isFinal) {
-      // We don't promote final variables on initialization, so pretend the
-      // written type is the variable's declared type.
-      initializerType = typeOperations.variableType(variable);
+      {required bool isFinal,
+      required bool isLate,
+      required bool isImplicitlyTyped}) {
+    ExpressionInfo<Variable, Type>? expressionInfo;
+    if (isLate) {
+      // Don't get expression info for late variables, since we don't know when
+      // they'll be initialized.
+    } else if (isImplicitlyTyped && !respectImplicitlyTypedVarInitializers) {
+      // If the language version is too old, SSA analysis has to ignore
+      // initializer expressions for implicitly typed variables, in order to
+      // preserve the buggy behavior of
+      // https://github.com/dart-lang/language/issues/1785.
+    } else {
+      expressionInfo = _getExpressionInfo(initializerExpression);
     }
+    SsaNode<Variable, Type> newSsaNode = new SsaNode<Variable, Type>(
+        expressionInfo is _TrivialExpressionInfo ? null : expressionInfo);
     _current = _current.write(
-        null, variable, initializerType, newSsaNode, typeOperations);
+        null, variable, initializerType, newSsaNode, typeOperations,
+        promoteToTypeOfInterest: !isImplicitlyTyped && !isFinal);
+    if (isImplicitlyTyped &&
+        typeOperations.isTypeParameterType(initializerType)) {
+      _current = _current
+          .tryPromoteForTypeCheck(
+              typeOperations,
+              new ReferenceWithType<Variable, Type>(
+                  new VariableReference<Variable, Type>(variable),
+                  promotedType(variable) ??
+                      typeOperations.variableType(variable)),
+              initializerType)
+          .ifTrue;
+    }
   }
 
   @override
@@ -3958,19 +3994,6 @@
   }
 
   @override
-  void promote(Variable variable, Type type) {
-    _current = _current
-        .tryPromoteForTypeCheck(
-            typeOperations,
-            new ReferenceWithType<Variable, Type>(
-                new VariableReference<Variable, Type>(variable),
-                promotedType(variable) ??
-                    typeOperations.variableType(variable)),
-            type)
-        .ifTrue;
-  }
-
-  @override
   Type? promotedType(Variable variable) {
     return _current.infoFor(variable).promotedTypes?.last;
   }
@@ -4544,7 +4567,9 @@
   @override
   void initialize(
       Variable variable, Type initializerType, Expression initializerExpression,
-      {required bool isFinal, required bool isLate}) {}
+      {required bool isFinal,
+      required bool isLate,
+      required bool isImplicitlyTyped}) {}
 
   @override
   bool isAssigned(Variable variable) {
@@ -4704,11 +4729,6 @@
   }
 
   @override
-  void promote(Variable variable, Type type) {
-    throw new UnimplementedError('TODO(paulberry)');
-  }
-
-  @override
   Type? promotedType(Variable variable) {
     return _knownTypes[variable];
   }
diff --git a/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart b/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart
index c1236e8..2546579 100644
--- a/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/parser/type_info.dart
@@ -370,32 +370,11 @@
 /// indicating that the `<` and `>` should be interpreted as operators (so two
 /// arguments are being passed to `f`: `a < b` and `c > -d`).
 bool mayFollowTypeArgs(Token token) {
+  const Set<String> continuationTokens = {'(', '.', '==', '!='};
+  const Set<String> stopTokens = {')', ']', '}', ';', ':', ','};
   const Set<String> tokensThatMayFollowTypeArg = {
-    '(',
-    ')',
-    ']',
-    '}',
-    ':',
-    ';',
-    ',',
-    '.',
-    '?',
-    '==',
-    '!=',
-    '..',
-    '?.',
-    '??',
-    '?..',
-    '&',
-    '|',
-    '^',
-    '+',
-    '*',
-    '%',
-    '/',
-    '~/',
-    'is',
-    'as'
+    ...continuationTokens,
+    ...stopTokens
   };
   if (token.type == TokenType.EOF) {
     // The spec doesn't have anything to say about this case, since an
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
index 31f5089..07b7e12 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
@@ -594,7 +594,8 @@
       var e = expr('Null');
       var s = if_(e, []);
       var flow = FlowAnalysis<Node, Statement, Expression, Var, Type>(
-          h, AssignedVariables<Node, Var>());
+          h, AssignedVariables<Node, Var>(),
+          respectImplicitlyTypedVarInitializers: true);
       flow.ifStatement_conditionBegin();
       flow.ifStatement_thenBegin(e, s);
       expect(() => flow.finish(), _asserts);
@@ -1308,6 +1309,75 @@
       ]);
     });
 
+    group('initialize() promotes implicitly typed vars to type parameter types',
+        () {
+      test('when not final', () {
+        var h = Harness()
+          ..addSubtype('T&int', 'T', true)
+          ..addFactor('T', 'T&int', 'T');
+        var x = Var('x', 'T', isImplicitlyTyped: true);
+        h.run([
+          declareInitialized(x, expr('T&int')),
+          checkPromoted(x, 'T&int'),
+        ]);
+      });
+
+      test('when final', () {
+        var h = Harness()
+          ..addSubtype('T&int', 'T', true)
+          ..addFactor('T', 'T&int', 'T');
+        var x = Var('x', 'T', isImplicitlyTyped: true);
+        h.run([
+          declareInitialized(x, expr('T&int'), isFinal: true),
+          checkPromoted(x, 'T&int'),
+        ]);
+      });
+    });
+
+    group(
+        "initialize() doesn't promote explicitly typed vars to type "
+        'parameter types', () {
+      test('when not final', () {
+        var h = Harness();
+        var x = Var('x', 'T');
+        h.run([
+          declareInitialized(x, expr('T&int')),
+          checkNotPromoted(x),
+        ]);
+      });
+
+      test('when final', () {
+        var h = Harness();
+        var x = Var('x', 'T');
+        h.run([
+          declareInitialized(x, expr('T&int'), isFinal: true),
+          checkNotPromoted(x),
+        ]);
+      });
+    });
+
+    group(
+        "initialize() doesn't promote implicitly typed vars to ordinary types",
+        () {
+      test('when not final', () {
+        var h = Harness();
+        var x = Var('x', 'dynamic', isImplicitlyTyped: true);
+        h.run([
+          declareInitialized(x, expr('Null')),
+          checkNotPromoted(x),
+        ]);
+      });
+
+      test('when final', () {
+        var h = Harness();
+        var x = Var('x', 'dynamic', isImplicitlyTyped: true);
+        h.run([
+          declareInitialized(x, expr('Null'), isFinal: true),
+          checkNotPromoted(x),
+        ]);
+      });
+    });
+
     test('initialize() stores expressionInfo when not late', () {
       var h = Harness();
       var x = Var('x', 'Object');
@@ -1338,6 +1408,48 @@
       ]);
     });
 
+    test(
+        'initialize() does not store expressionInfo for implicitly typed '
+        'vars, pre-bug fix', () {
+      var h = Harness(respectImplicitlyTypedVarInitializers: false);
+      var x = Var('x', 'Object', isImplicitlyTyped: true);
+      var y = Var('y', 'int?');
+      h.run([
+        declareInitialized(x, y.expr.eq(nullLiteral)),
+        getSsaNodes((nodes) {
+          expect(nodes[x]!.expressionInfo, isNull);
+        }),
+      ]);
+    });
+
+    test(
+        'initialize() stores expressionInfo for implicitly typed '
+        'vars, post-bug fix', () {
+      var h = Harness(respectImplicitlyTypedVarInitializers: true);
+      var x = Var('x', 'Object', isImplicitlyTyped: true);
+      var y = Var('y', 'int?');
+      h.run([
+        declareInitialized(x, y.expr.eq(nullLiteral)),
+        getSsaNodes((nodes) {
+          expect(nodes[x]!.expressionInfo, isNotNull);
+        }),
+      ]);
+    });
+
+    test(
+        'initialize() stores expressionInfo for explicitly typed '
+        'vars, pre-bug fix', () {
+      var h = Harness(respectImplicitlyTypedVarInitializers: false);
+      var x = Var('x', 'Object');
+      var y = Var('y', 'int?');
+      h.run([
+        declareInitialized(x, y.expr.eq(nullLiteral)),
+        getSsaNodes((nodes) {
+          expect(nodes[x]!.expressionInfo, isNotNull);
+        }),
+      ]);
+    });
+
     test('initialize() does not store expressionInfo for trivial expressions',
         () {
       var h = Harness();
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/nullability/data/local_boolean.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/nullability/data/local_boolean.dart
index 7fd0b63..32dd3c6 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/nullability/data/local_boolean.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/nullability/data/local_boolean.dart
@@ -2,6 +2,8 @@
 // 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.13
+
 finalLocalBool(int? x) {
   final bool b = x == null;
   if (!b) {
diff --git a/pkg/_fe_analyzer_shared/test/mini_ast.dart b/pkg/_fe_analyzer_shared/test/mini_ast.dart
index b8ce9e9..57ce172 100644
--- a/pkg/_fe_analyzer_shared/test/mini_ast.dart
+++ b/pkg/_fe_analyzer_shared/test/mini_ast.dart
@@ -388,7 +388,17 @@
 
   late final _typeAnalyzer = _MiniAstTypeAnalyzer(this);
 
-  Harness({this.legacy = false, String? thisType})
+  /// Indicates whether initializers of implicitly typed variables should be
+  /// accounted for by SSA analysis.  (In an ideal world, they always would be,
+  /// but due to https://github.com/dart-lang/language/issues/1785, they weren't
+  /// always, and we need to be able to replicate the old behavior when
+  /// analyzing old language versions).
+  final bool respectImplicitlyTypedVarInitializers;
+
+  Harness(
+      {this.legacy = false,
+      String? thisType,
+      this.respectImplicitlyTypedVarInitializers = true})
       : thisType = thisType == null ? null : Type(thisType);
 
   MiniIrBuilder get _irBuilder => _typeAnalyzer._irBuilder;
@@ -460,6 +470,9 @@
   }
 
   @override
+  bool isTypeParameterType(Type type) => type is PromotedTypeVariableType;
+
+  @override
   Type promoteToNonNull(Type type) {
     if (type.type.endsWith('?')) {
       return Type(type.type.substring(0, type.type.length - 1));
@@ -480,7 +493,9 @@
         ? FlowAnalysis<Node, Statement, Expression, Var, Type>.legacy(
             this, assignedVariables)
         : FlowAnalysis<Node, Statement, Expression, Var, Type>(
-            this, assignedVariables);
+            this, assignedVariables,
+            respectImplicitlyTypedVarInitializers:
+                respectImplicitlyTypedVarInitializers);
     _typeAnalyzer.dispatchStatement(b);
     _typeAnalyzer.finish();
   }
@@ -649,8 +664,10 @@
 class Var {
   final String name;
   final Type type;
+  final bool isImplicitlyTyped;
 
-  Var(this.name, String typeStr) : type = Type(typeStr);
+  Var(this.name, String typeStr, {this.isImplicitlyTyped = false})
+      : type = Type(typeStr);
 
   /// Creates an L-value representing a reference to this variable.
   LValue get expr => new _VariableReference(this, null);
@@ -1608,7 +1625,9 @@
       var initializerType = analyzeExpression(initializer);
       flow.declare(variable, true);
       flow.initialize(variable, initializerType, initializer,
-          isFinal: isFinal, isLate: isLate);
+          isFinal: isFinal,
+          isLate: isLate,
+          isImplicitlyTyped: variable.isImplicitlyTyped);
     }
   }
 
diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index 76b327e..dd94f01 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -267,6 +267,7 @@
   CompileTimeErrorCode.LATE_FINAL_FIELD_WITH_CONST_CONSTRUCTOR,
   CompileTimeErrorCode.LATE_FINAL_LOCAL_ALREADY_ASSIGNED,
   CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
+  CompileTimeErrorCode.MACRO_EXECUTION_ERROR,
   CompileTimeErrorCode.MAIN_FIRST_POSITIONAL_PARAMETER_TYPE,
   CompileTimeErrorCode.MAIN_HAS_REQUIRED_NAMED_PARAMETERS,
   CompileTimeErrorCode.MAIN_HAS_TOO_MANY_REQUIRED_POSITIONAL_PARAMETERS,
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 61f515c..433fcaa 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -80,7 +80,7 @@
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 172;
+  static const int DATA_VERSION = 174;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index ec1e0ed..57d2d82 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -43,6 +43,7 @@
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
+import 'package:analyzer/src/macro/impl/error.dart' as macro;
 import 'package:analyzer/src/summary2/ast_binary_tokens.dart';
 import 'package:analyzer/src/summary2/bundle_reader.dart';
 import 'package:analyzer/src/summary2/reference.dart';
@@ -447,6 +448,10 @@
   /// TODO(scheglov) implement as modifier
   bool _isSimplyBounded = true;
 
+  /// The list of errors recorded during execution of macro builders
+  /// over this class.
+  List<macro.MacroExecutionError> macroExecutionErrors = [];
+
   ElementLinkedData? linkedData;
 
   /// Initialize a newly created class element to have the given [name] at the
diff --git a/pkg/analyzer/lib/src/dart/error/hint_codes.dart b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
index 24533f2..ba78ccb 100644
--- a/pkg/analyzer/lib/src/dart/error/hint_codes.dart
+++ b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
@@ -2230,7 +2230,7 @@
       // your pubspec.yaml to set the minimum SDK constraint to 2.14 or
       // higher, and running 'pub get'."
       correction: "Try enabling the experiment by including "
-          "'--enable-experiments=constructor-tearoffs' in the 'dart' command.");
+          "'--enable-experiment=constructor-tearoffs' in the 'dart' command.");
 
   /**
    * No parameters.
diff --git a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
index 8b431a0..5b6a4fb 100644
--- a/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart
@@ -13,6 +13,7 @@
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_system.dart' show TypeSystemImpl;
 import 'package:analyzer/src/generated/migration.dart';
+import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/variable_type_provider.dart';
 
 /// Data gathered by flow analysis, retained for testing purposes.
@@ -222,7 +223,8 @@
     flow!.labeledStatement_end();
   }
 
-  void topLevelDeclaration_enter(AstNode node, FormalParameterList? parameters,
+  void topLevelDeclaration_enter(
+      ResolverVisitor resolver, AstNode node, FormalParameterList? parameters,
       {void Function(AstVisitor<Object?> visitor)? visit}) {
     assert(flow == null);
     assignedVariables = computeAssignedVariables(node, parameters,
@@ -233,7 +235,9 @@
     }
     flow = isNonNullableByDefault
         ? FlowAnalysis<AstNode, Statement, Expression, PromotableElement,
-            DartType>(_typeOperations, assignedVariables!)
+                DartType>(_typeOperations, assignedVariables!,
+            respectImplicitlyTypedVarInitializers:
+                resolver.isConstructorTearoffsEnabled)
         : FlowAnalysis<AstNode, Statement, Expression, PromotableElement,
             DartType>.legacy(_typeOperations, assignedVariables!);
   }
@@ -349,9 +353,10 @@
       : super(typeSystem, false, isNonNullableByDefault);
 
   @override
-  void topLevelDeclaration_enter(AstNode node, FormalParameterList? parameters,
+  void topLevelDeclaration_enter(
+      ResolverVisitor resolver, AstNode node, FormalParameterList? parameters,
       {void Function(AstVisitor<Object?> visitor)? visit}) {
-    super.topLevelDeclaration_enter(node, parameters, visit: visit);
+    super.topLevelDeclaration_enter(resolver, node, parameters, visit: visit);
     migrationResolutionHooks.setFlowAnalysis(flow);
   }
 
@@ -400,6 +405,9 @@
   }
 
   @override
+  bool isTypeParameterType(DartType type) => type is TypeParameterType;
+
+  @override
   DartType promoteToNonNull(DartType type) {
     return typeSystem.promoteToNonNull(type);
   }
diff --git a/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart
index 1e41759..3654269 100644
--- a/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/variable_declaration_resolver.dart
@@ -45,7 +45,7 @@
 
     InferenceContext.setTypeFromNode(initializer, node);
     if (isTopLevel) {
-      _resolver.flowAnalysis.topLevelDeclaration_enter(node, null);
+      _resolver.flowAnalysis.topLevelDeclaration_enter(_resolver, node, null);
     } else if (element.isLate) {
       _resolver.flowAnalysis.flow?.lateInitializer_begin(node);
     }
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index 6a29b7d..e2e2151 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -7653,6 +7653,15 @@
           hasPublishedDocs: true);
 
   /**
+   * Parameters:
+   * 0: the name of the macro
+   * 1: the message
+   */
+  static const CompileTimeErrorCode MACRO_EXECUTION_ERROR =
+      CompileTimeErrorCode(
+          'MACRO_EXECUTION_ERROR', "Exception thrown by macro {0}: {1}");
+
+  /**
    * No parameters.
    */
   // #### Description
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index 7f5d9e6..f68eea7 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -45,6 +45,7 @@
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/this_access_tracker.dart';
+import 'package:analyzer/src/macro/impl/error.dart' as macro;
 import 'package:collection/collection.dart';
 
 class EnclosingExecutableContext {
@@ -444,7 +445,8 @@
     var outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
-      _enclosingClass = node.declaredElement as ClassElementImpl;
+      var enclosingClass = node.declaredElement as ClassElementImpl;
+      _enclosingClass = enclosingClass;
 
       List<ClassMember> members = node.members;
       _duplicateDefinitionVerifier.checkClass(node);
@@ -468,6 +470,10 @@
       _checkForBadFunctionUse(node);
       _checkForWrongTypeParameterVarianceInSuperinterfaces();
       _checkForMainFunction(node.name);
+      _reportMacroExecutionErrors(
+        node.metadata,
+        enclosingClass.macroExecutionErrors,
+      );
       super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
@@ -4986,6 +4992,23 @@
     return null;
   }
 
+  /// Report [macroExecutionErrors] at the corresponding [annotations].
+  void _reportMacroExecutionErrors(
+    List<Annotation> annotations,
+    List<macro.MacroExecutionError> macroExecutionErrors,
+  ) {
+    for (var macroExecutionError in macroExecutionErrors) {
+      errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.MACRO_EXECUTION_ERROR,
+        annotations[macroExecutionError.annotationIndex],
+        [
+          macroExecutionError.macroName,
+          macroExecutionError.message,
+        ],
+      );
+    }
+  }
+
   void _withEnclosingExecutable(
     ExecutableElement element,
     void Function() operation,
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 2ef5319..4fc7f04 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -1185,7 +1185,7 @@
 
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
-    flowAnalysis.topLevelDeclaration_enter(node, node.parameters);
+    flowAnalysis.topLevelDeclaration_enter(this, node, node.parameters);
     flowAnalysis.executableDeclaration_enter(node, node.parameters, false);
 
     var returnType = node.declaredElement!.type.returnType;
@@ -1409,7 +1409,7 @@
       flowAnalysis.flow!.functionExpression_begin(node);
     } else {
       flowAnalysis.topLevelDeclaration_enter(
-          node, node.functionExpression.parameters);
+          this, node, node.functionExpression.parameters);
     }
     flowAnalysis.executableDeclaration_enter(
       node,
@@ -1638,7 +1638,7 @@
 
   @override
   void visitMethodDeclaration(MethodDeclaration node) {
-    flowAnalysis.topLevelDeclaration_enter(node, node.parameters);
+    flowAnalysis.topLevelDeclaration_enter(this, node, node.parameters);
     flowAnalysis.executableDeclaration_enter(node, node.parameters, false);
 
     DartType returnType = node.declaredElement!.returnType;
@@ -2014,17 +2014,11 @@
     var declaredType = parent.type;
     if (initializer != null) {
       var initializerStaticType = initializer.typeOrThrow;
-      if (declaredType == null) {
-        if (_isNonNullableByDefault &&
-            initializerStaticType is TypeParameterType) {
-          flowAnalysis.flow?.promote(
-              declaredElement as PromotableElement, initializerStaticType);
-        }
-      } else {
-        flowAnalysis.flow?.initialize(declaredElement as PromotableElement,
-            initializerStaticType, initializer,
-            isFinal: parent.isFinal, isLate: parent.isLate);
-      }
+      flowAnalysis.flow?.initialize(declaredElement as PromotableElement,
+          initializerStaticType, initializer,
+          isFinal: parent.isFinal,
+          isLate: parent.isLate,
+          isImplicitlyTyped: declaredType == null);
     }
   }
 
diff --git a/pkg/analyzer/lib/src/macro/impl/error.dart b/pkg/analyzer/lib/src/macro/impl/error.dart
new file mode 100644
index 0000000..8c2780c
--- /dev/null
+++ b/pkg/analyzer/lib/src/macro/impl/error.dart
@@ -0,0 +1,16 @@
+// 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 file.
+
+/// Error that happened during executing a macro builder.
+class MacroExecutionError {
+  final int annotationIndex;
+  final String macroName;
+  final String message;
+
+  MacroExecutionError({
+    required this.annotationIndex,
+    required this.macroName,
+    required this.message,
+  });
+}
diff --git a/pkg/analyzer/lib/src/summary2/ast_resolver.dart b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
index 96f8760..04523e4 100644
--- a/pkg/analyzer/lib/src/summary2/ast_resolver.dart
+++ b/pkg/analyzer/lib/src/summary2/ast_resolver.dart
@@ -58,7 +58,7 @@
     node.accept(_resolutionVisitor);
     node.accept(_scopeResolverVisitor);
     _prepareEnclosingDeclarations();
-    _flowAnalysis.topLevelDeclaration_enter(node, null);
+    _flowAnalysis.topLevelDeclaration_enter(_resolverVisitor, node, null);
     node.accept(_resolverVisitor);
     _flowAnalysis.topLevelDeclaration_exit();
   }
@@ -76,7 +76,8 @@
     visit(_scopeResolverVisitor);
 
     _prepareEnclosingDeclarations();
-    _flowAnalysis.topLevelDeclaration_enter(node, node.parameters,
+    _flowAnalysis.topLevelDeclaration_enter(
+        _resolverVisitor, node, node.parameters,
         visit: visit);
     visit(_resolverVisitor);
     _flowAnalysis.topLevelDeclaration_exit();
@@ -95,7 +96,8 @@
       node.accept(_scopeResolverVisitor);
     }
     _prepareEnclosingDeclarations();
-    _flowAnalysis.topLevelDeclaration_enter(node.parent!, null);
+    _flowAnalysis.topLevelDeclaration_enter(
+        _resolverVisitor, node.parent!, null);
     node.accept(_resolverVisitor);
     _flowAnalysis.topLevelDeclaration_exit();
   }
diff --git a/pkg/analyzer/lib/src/summary2/bundle_reader.dart b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
index bdfc35d..f406b41 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
@@ -18,6 +18,7 @@
 import 'package:analyzer/src/dart/resolver/variance.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/macro/impl/error.dart' as macro;
 import 'package:analyzer/src/summary2/ast_binary_reader.dart';
 import 'package:analyzer/src/summary2/ast_binary_tag.dart';
 import 'package:analyzer/src/summary2/data_reader.dart';
@@ -528,6 +529,10 @@
     element.setLinkedData(reference, linkedData);
     ClassElementFlags.read(_reader, element);
 
+    element.macroExecutionErrors = _reader.readTypedList(
+      _readMacroExecutionError,
+    );
+
     element.typeParameters = _readTypeParameters();
 
     if (!element.isMixinApplication) {
@@ -866,6 +871,14 @@
     }
   }
 
+  macro.MacroExecutionError _readMacroExecutionError() {
+    return macro.MacroExecutionError(
+      annotationIndex: _reader.readUInt30(),
+      macroName: _reader.readStringReference(),
+      message: _reader.readStringReference(),
+    );
+  }
+
   List<MethodElementImpl> _readMethods(
     CompilationUnitElementImpl unitElement,
     ElementImpl enclosingElement,
diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
index 6c96d5e..44dcc92 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
@@ -14,6 +14,7 @@
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/resolver/variance.dart';
+import 'package:analyzer/src/macro/impl/error.dart' as macro;
 import 'package:analyzer/src/summary2/ast_binary_tag.dart';
 import 'package:analyzer/src/summary2/ast_binary_writer.dart';
 import 'package:analyzer/src/summary2/data_writer.dart';
@@ -129,6 +130,11 @@
     _sink._writeStringReference(element.name);
     ClassElementFlags.write(_sink, element);
 
+    _writeList(
+      element.macroExecutionErrors,
+      _sink._writeMacroExecutionError,
+    );
+
     _resolutionSink._writeAnnotationList(element.metadata);
 
     _writeTypeParameters(element.typeParameters, () {
@@ -974,6 +980,12 @@
     }
   }
 
+  void _writeMacroExecutionError(macro.MacroExecutionError error) {
+    writeUInt30(error.annotationIndex);
+    _writeStringReference(error.macroName);
+    _writeStringReference(error.message);
+  }
+
   void _writeOptionalStringReference(String? value) {
     if (value != null) {
       writeBool(true);
diff --git a/pkg/analyzer/lib/src/summary2/library_builder.dart b/pkg/analyzer/lib/src/summary2/library_builder.dart
index 8cadf5b..4b894a9 100644
--- a/pkg/analyzer/lib/src/summary2/library_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/library_builder.dart
@@ -8,8 +8,10 @@
 import 'package:analyzer/src/dart/ast/mixin_super_invoked_names.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/resolver/scope.dart';
+import 'package:analyzer/src/macro/api/macro.dart' as macro;
 import 'package:analyzer/src/macro/builders/data_class.dart' as macro;
 import 'package:analyzer/src/macro/builders/observable.dart' as macro;
+import 'package:analyzer/src/macro/impl/error.dart' as macro;
 import 'package:analyzer/src/macro/impl/macro.dart' as macro;
 import 'package:analyzer/src/summary2/combinator.dart';
 import 'package:analyzer/src/summary2/constructor_initializer_resolver.dart';
@@ -200,19 +202,25 @@
 
   /// Run built-in declaration macros.
   void runDeclarationMacros() {
-    bool hasMacroAnnotation(ast.AnnotatedNode node, String name) {
-      for (var annotation in node.metadata) {
+    /// If [node] has a macro annotation with the required [name],
+    /// return the index of this annotation node.
+    int? hasMacroAnnotation(ast.AnnotatedNode node, String name) {
+      var metadata = node.metadata;
+      for (var i = 0; i < metadata.length; i++) {
+        var annotation = metadata[i];
         var nameNode = annotation.name;
         if (nameNode is ast.SimpleIdentifier &&
             annotation.arguments == null &&
             annotation.constructorName == null &&
             nameNode.name == name) {
           var nameElement = element.scope.lookup(name).getter;
-          return nameElement != null &&
-              nameElement.library?.name == 'analyzer.macro.annotations';
+          if (nameElement != null &&
+              nameElement.library?.name == 'analyzer.macro.annotations') {
+            return i;
+          }
         }
       }
-      return false;
+      return null;
     }
 
     /// Build types for type annotations in new [nodes].
@@ -236,39 +244,53 @@
       for (var declaration in linkingUnit.node.declarations) {
         if (declaration is ast.ClassDeclarationImpl) {
           classDeclarationIndex++;
+          var macroExecutionErrors = <macro.MacroExecutionError>[];
+
           var members = declaration.members.toList();
           var classBuilder = macro.ClassDeclarationBuilderImpl(
             linkingUnit,
             classDeclarationIndex,
             declaration,
           );
-          if (hasMacroAnnotation(declaration, 'autoConstructor')) {
-            macro.AutoConstructorMacro().visitClassDeclaration(
-              declaration,
-              classBuilder,
-            );
+
+          void runClassMacro(
+            String name,
+            macro.ClassDeclarationMacro Function() newInstance,
+          ) {
+            var annotationIndex = hasMacroAnnotation(declaration, name);
+            if (annotationIndex != null) {
+              try {
+                newInstance().visitClassDeclaration(
+                  declaration,
+                  classBuilder,
+                );
+              } catch (e) {
+                macroExecutionErrors.add(
+                  macro.MacroExecutionError(
+                    annotationIndex: annotationIndex,
+                    macroName: name,
+                    message: e.toString(),
+                  ),
+                );
+              }
+            }
           }
-          if (hasMacroAnnotation(declaration, 'dataClass')) {
-            macro.DataClassMacro().visitClassDeclaration(
-              declaration,
-              classBuilder,
-            );
-          }
-          if (hasMacroAnnotation(declaration, 'hashCode')) {
-            macro.HashCodeMacro().visitClassDeclaration(
-              declaration,
-              classBuilder,
-            );
-          }
-          if (hasMacroAnnotation(declaration, 'toString')) {
-            macro.ToStringMacro().visitClassDeclaration(
-              declaration,
-              classBuilder,
-            );
-          }
+
+          runClassMacro('autoConstructor', () => macro.AutoConstructorMacro());
+          runClassMacro('dataClass', () => macro.DataClassMacro());
+          runClassMacro('hashCode', () => macro.HashCodeMacro());
+          runClassMacro('toString', () => macro.ToStringMacro());
+
+          var classElement = declaration.declaredElement as ClassElementImpl;
+          classElement.macroExecutionErrors = macroExecutionErrors;
+
           for (var member in members) {
             if (member is ast.FieldDeclarationImpl) {
-              if (hasMacroAnnotation(member, 'observable')) {
+              var annotationIndex = hasMacroAnnotation(
+                member,
+                'observable',
+              );
+              if (annotationIndex != null) {
                 macro.ObservableMacro().visitFieldDeclaration(
                   member,
                   classBuilder,
diff --git a/pkg/analyzer/test/generated/function_reference_parser_test.dart b/pkg/analyzer/test/generated/function_reference_parser_test.dart
index e76a9a7..89ffcb5 100644
--- a/pkg/analyzer/test/generated/function_reference_parser_test.dart
+++ b/pkg/analyzer/test/generated/function_reference_parser_test.dart
@@ -44,41 +44,6 @@
     ]);
   }
 
-  void test_followingToken_accepted_ampersand() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> & 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
-  void test_followingToken_accepted_as() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> as int', featureSet: constructorTearoffs)
-                as AsExpression)
-            .expression);
-  }
-
-  void test_followingToken_accepted_asterisk() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> * 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
-  void test_followingToken_accepted_bar() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> | 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
-  void test_followingToken_accepted_caret() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> ^ 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
   void test_followingToken_accepted_closeBrace() {
     expect_f_a_b((parseExpression('{f<a, b>}', featureSet: constructorTearoffs)
             as SetOrMapLiteral)
@@ -120,13 +85,6 @@
             .leftOperand);
   }
 
-  void test_followingToken_accepted_is() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> is int', featureSet: constructorTearoffs)
-                as IsExpression)
-            .expression);
-  }
-
   void test_followingToken_accepted_not_equals() {
     expect_f_a_b(
         (parseExpression('f<a, b> != null', featureSet: constructorTearoffs)
@@ -148,13 +106,6 @@
     expect(methodInvocation.argumentList.arguments, isEmpty);
   }
 
-  void test_followingToken_accepted_percent() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> % 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
   void test_followingToken_accepted_period_methodInvocation() {
     // This is a special case because `f<a, b>.methodName(...)` is parsed as an
     // InstanceCreationExpression.
@@ -179,13 +130,6 @@
             .target!);
   }
 
-  void test_followingToken_accepted_period_period() {
-    expect_f_a_b(
-        (parseExpression('f<a, b>..toString()', featureSet: constructorTearoffs)
-                as CascadeExpression)
-            .target);
-  }
-
   void test_followingToken_accepted_period_propertyAccess() {
     expect_f_a_b(
         (parseExpression('f<a, b>.hashCode', featureSet: constructorTearoffs)
@@ -193,53 +137,6 @@
             .target!);
   }
 
-  void test_followingToken_accepted_plus() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> + 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
-  void test_followingToken_accepted_question() {
-    expect_f_a_b((parseExpression('f<a, b> ? null : null',
-            featureSet: constructorTearoffs) as ConditionalExpression)
-        .condition);
-  }
-
-  void test_followingToken_accepted_question_period_methodInvocation() {
-    expect_f_a_b(
-        (parseExpression('f<a, b>?.toString()', featureSet: constructorTearoffs)
-                as MethodInvocation)
-            .target!);
-  }
-
-  void test_followingToken_accepted_question_period_methodInvocation_generic() {
-    expect_f_a_b(
-        (parseExpression('f<a, b>?.foo<c>()', featureSet: constructorTearoffs)
-                as MethodInvocation)
-            .target!);
-  }
-
-  void test_followingToken_accepted_question_period_period() {
-    expect_f_a_b((parseExpression('f<a, b>?..toString()',
-            featureSet: constructorTearoffs) as CascadeExpression)
-        .target);
-  }
-
-  void test_followingToken_accepted_question_period_propertyAccess() {
-    expect_f_a_b(
-        (parseExpression('f<a, b>?.hashCode', featureSet: constructorTearoffs)
-                as PropertyAccess)
-            .target!);
-  }
-
-  void test_followingToken_accepted_question_question() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> ?? 0', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
-  }
-
   void test_followingToken_accepted_semicolon() {
     expect_f_a_b((parseStatement('f<a, b>;', featureSet: constructorTearoffs)
             as ExpressionStatement)
@@ -247,18 +144,26 @@
     listener.assertNoErrors();
   }
 
-  void test_followingToken_accepted_slash() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> / 1', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
+  void test_followingToken_rejected_ampersand() {
+    expect_two_args(parseExpression('f(a<b,c>&d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
   }
 
-  void test_followingToken_accepted_tilde_slash() {
-    expect_f_a_b(
-        (parseExpression('f<a, b> ~/ 1', featureSet: constructorTearoffs)
-                as BinaryExpression)
-            .leftOperand);
+  void test_followingToken_rejected_as() {
+    expect_two_args(
+        parseExpression('f(a<b,c>as)', featureSet: constructorTearoffs)
+            as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_asterisk() {
+    expect_two_args(parseExpression('f(a<b,c>*d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
   }
 
   void test_followingToken_rejected_bang_openBracket() {
@@ -273,6 +178,34 @@
             as MethodInvocation);
   }
 
+  void test_followingToken_rejected_bar() {
+    expect_two_args(parseExpression('f(a<b,c>|d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_caret() {
+    expect_two_args(parseExpression('f(a<b,c>^d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_is() {
+    var methodInvocation = parseExpression('f(a<b,c> is int)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation;
+    var arguments = methodInvocation.argumentList.arguments;
+    expect(arguments, hasLength(2));
+    expect(arguments[0], TypeMatcher<BinaryExpression>());
+    expect(arguments[1], TypeMatcher<IsExpression>());
+  }
+
   void test_followingToken_rejected_lessThan() {
     // Note: in principle we could parse this as a generic instantiation of a
     // generic instantiation, but such an expression would be meaningless so we
@@ -314,6 +247,108 @@
             as MethodInvocation);
   }
 
+  void test_followingToken_rejected_percent() {
+    expect_two_args(parseExpression('f(a<b,c>%d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_period_period() {
+    var methodInvocation = parseExpression('f(a<b,c>..toString())',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation;
+    var arguments = methodInvocation.argumentList.arguments;
+    expect(arguments, hasLength(2));
+    expect(arguments[0], TypeMatcher<BinaryExpression>());
+    expect(arguments[1], TypeMatcher<CascadeExpression>());
+  }
+
+  void test_followingToken_rejected_plus() {
+    expect_two_args(parseExpression('f(a<b,c>+d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_question() {
+    var methodInvocation = parseExpression('f(a<b,c> ? null : null)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation;
+    var arguments = methodInvocation.argumentList.arguments;
+    expect(arguments, hasLength(2));
+    expect(arguments[0], TypeMatcher<BinaryExpression>());
+    expect(arguments[1], TypeMatcher<ConditionalExpression>());
+  }
+
+  void test_followingToken_rejected_question_period_methodInvocation() {
+    expect_two_args(parseExpression('f(a<b,c>?.toString())',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_question_period_methodInvocation_generic() {
+    expect_two_args(parseExpression('f(a<b,c>?.foo<c>())',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_question_period_period() {
+    var methodInvocation = parseExpression('f(a<b,c>?..toString())',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 3),
+          expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 8),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation;
+    var arguments = methodInvocation.argumentList.arguments;
+    expect(arguments, hasLength(3));
+    expect(arguments[0], TypeMatcher<BinaryExpression>());
+    expect(arguments[1], TypeMatcher<BinaryExpression>());
+    expect(arguments[2], TypeMatcher<MethodInvocation>());
+  }
+
+  void test_followingToken_rejected_question_period_propertyAccess() {
+    expect_two_args(parseExpression('f(a<b,c>?.hashCode)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_question_question() {
+    expect_two_args(parseExpression('f(a<b,c> ?? d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 9, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_slash() {
+    expect_two_args(parseExpression('f(a<b,c>/d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 1),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
+  void test_followingToken_rejected_tilde_slash() {
+    expect_two_args(parseExpression('f(a<b,c>~/d)',
+        errors: [
+          expectedError(ParserErrorCode.MISSING_IDENTIFIER, 8, 2),
+        ],
+        featureSet: constructorTearoffs) as MethodInvocation);
+  }
+
   void test_functionReference_after_indexExpression() {
     // Note: this is not legal Dart, but it's important that we do error
     // recovery and don't crash the parser.
diff --git a/pkg/analyzer/test/src/dart/resolution/constructor_reference_test.dart b/pkg/analyzer/test/src/dart/resolution/constructor_reference_test.dart
index 769396f..eba7e07 100644
--- a/pkg/analyzer/test/src/dart/resolution/constructor_reference_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/constructor_reference_test.dart
@@ -2,7 +2,7 @@
 // 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -150,19 +150,17 @@
   A<int>..foo;
 }
 ''', [
-      error(CompileTimeErrorCode.UNDEFINED_GETTER, 50, 3),
+      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 43, 1),
+      error(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 47, 1),
+      error(ParserErrorCode.MISSING_IDENTIFIER, 48, 2),
     ]);
-
-    // The nodes are not rewritten into a [ConstructorReference].
-    var cascade = findNode.cascade('A<int>..foo;');
-    assertType(cascade, 'Type');
-    var section = cascade.cascadeSections.first as PropertyAccess;
-    assertType(section, 'dynamic');
-    assertType(section.propertyName, 'dynamic');
+    // The parser produces nonsense here because the `<` disambiguates as a
+    // relational operator, so no need to assert anything about analysis
+    // results.
   }
 
   test_class_generic_named_nullAware() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 class A<T> {
   A.foo();
 }
@@ -170,17 +168,14 @@
 void bar() {
   A<int>?.foo;
 }
-''');
-
-    var classElement = findElement.class_('A');
-    assertConstructorReference(
-      findNode.constructorReference('A<int>?.foo;'),
-      elementMatcher(classElement.getNamedConstructor('foo')!,
-          substitution: {'T': 'int'}),
-      classElement,
-      'A<int> Function()',
-      expectedTypeNameType: 'A<int>',
-    );
+''', [
+      error(CompileTimeErrorCode.UNDEFINED_OPERATOR, 43, 1),
+      error(ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, 47, 1),
+      error(ParserErrorCode.MISSING_IDENTIFIER, 48, 2),
+    ]);
+    // The parser produces nonsense here because the `<` disambiguates as a
+    // relational operator, so no need to assert anything about analysis
+    // results.
   }
 
   test_class_generic_named_typeArgs() async {
diff --git a/pkg/analyzer/test/src/dart/resolution/macro_test.dart b/pkg/analyzer/test/src/dart/resolution/macro_test.dart
index b309301..a2e3aa4 100644
--- a/pkg/analyzer/test/src/dart/resolution/macro_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/macro_test.dart
@@ -101,6 +101,20 @@
     ]);
   }
 
+  test_executionError_autoConstructor() async {
+    await assertErrorsInCode(r'''
+import 'macro_annotations.dart';
+
+@autoConstructor
+class A {
+  final int a;
+  A(this.a);
+}
+''', [
+      error(CompileTimeErrorCode.MACRO_EXECUTION_ERROR, 34, 16),
+    ]);
+  }
+
   test_observable() async {
     var code = r'''
 import 'macro_annotations.dart';
diff --git a/pkg/analyzer/test/src/diagnostics/non_constant_map_element_test.dart b/pkg/analyzer/test/src/diagnostics/non_constant_map_element_test.dart
index f60e50d..35beee6 100644
--- a/pkg/analyzer/test/src/diagnostics/non_constant_map_element_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/non_constant_map_element_test.dart
@@ -79,12 +79,14 @@
   }
 
   test_ifElementWithElse_mayBeConst() async {
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 void main() {
   const isTrue = true;
   const {1: null, if (isTrue) null: null else null: null};
 }
-''');
+''', [
+      error(HintCode.DEAD_CODE, 83, 12),
+    ]);
   }
 
   test_spreadElement_mayBeConst() async {
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index b6b2ccb..02efb6f 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -6458,20 +6458,15 @@
     }
     if (initializerResult != null) {
       DartType initializerType = initializerResult.inferredType;
-      if (node.isImplicitlyTyped) {
-        if (inferrer.isNonNullableByDefault &&
-            initializerType is TypeParameterType) {
-          inferrer.flowAnalysis.promote(node, initializerType);
-        }
-      } else {
-        // TODO(paulberry): `initializerType` is sometimes `null` during top
-        // level inference.  Figure out how to prevent this.
-        // ignore: unnecessary_null_comparison
-        if (initializerType != null) {
-          inferrer.flowAnalysis.initialize(
-              node, initializerType, initializerResult.expression,
-              isFinal: node.isFinal, isLate: node.isLate);
-        }
+      // TODO(paulberry): `initializerType` is sometimes `null` during top
+      // level inference.  Figure out how to prevent this.
+      // ignore: unnecessary_null_comparison
+      if (initializerType != null) {
+        inferrer.flowAnalysis.initialize(
+            node, initializerType, initializerResult.expression,
+            isFinal: node.isFinal,
+            isLate: node.isLate,
+            isImplicitlyTyped: node.isImplicitlyTyped);
       }
       Expression initializer = inferrer.ensureAssignableResult(
           node.type, initializerResult,
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
index 5ba0cfa..884dfc4 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inference_engine.dart
@@ -312,6 +312,9 @@
   }
 
   @override
+  bool isTypeParameterType(DartType type) => type is TypeParameterType;
+
+  @override
   DartType tryPromoteToType(DartType to, DartType from) {
     if (isSubtypeOf(to, from)) {
       return to;
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index ff7e4aa..8ff9315 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -224,7 +224,9 @@
         flowAnalysis = library.isNonNullableByDefault
             ? new FlowAnalysis(
                 new TypeOperationsCfe(engine.typeSchemaEnvironment),
-                assignedVariables)
+                assignedVariables,
+                respectImplicitlyTypedVarInitializers:
+                    library.enableConstructorTearOffsInLibrary)
             : new FlowAnalysis.legacy(
                 new TypeOperationsCfe(engine.typeSchemaEnvironment),
                 assignedVariables) {}
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart
index dfe8eeb..2f3c136 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart
@@ -5,66 +5,43 @@
 // The test cases called `typeArgs_...` verify that `<` and `>` are treated as
 // delimiting type arguments when the `>` is followed by one of the tokens:
 //
-//     ( ) ] } : ; , . ? == != .. ?. ?? ?..
-//     & | ^ + * %  / ~/
-//
-// Unless otherwise noted, these test cases should not result in a parse error,
-// because they can be made into valid expressions through user-defined
-// operators.
+//     ( . == != ) ] } ; : ,
 
-var typeArgs_ampersand = f<a, b> & 0;
-var typeArgs_as = f<a, b> as int;
-var typeArgs_asterisk = f<a, b> * 0;
-var typeArgs_bar = f<a, b> | 0;
-var typeArgs_caret = f<a, b> ^ 0;
 var typeArgs_closeBrace = {f<a, b>};
 var typeArgs_closeBracket = [f<a, b>];
 var typeArgs_closeParen = g(f<a, b>);
 var typeArgs_colon = {f<a, b>: null};
 var typeArgs_comma = [f<a, b>, null];
 var typeArgs_equals = f<a, b> == null;
-var typeArgs_is = f<a, b> is int;
 var typeArgs_not_equals = f<a, b> != null;
 
 // This is a special case because when a `(` follows `<typeArguments>` it is
 // parsed as a MethodInvocation rather than a GenericInstantiation.
 var typeArgs_openParen = f<a, b>();
 
-var typeArgs_percent = f<a, b> % 0;
-
 // This is a special case because `f<a, b>.methodName(...)` is parsed as an
 // InstanceCreationExpression.
 var typeArgs_period_methodInvocation = f<a, b>.toString();
 
 var typeArgs_period_methodInvocation_generic = f<a, b>.foo<c>();
-var typeArgs_period_period = f<a, b>..toString();
 var typeArgs_period_propertyAccess = f<a, b>.hashCode;
-var typeArgs_plus = f<a, b> + 0;
 
-// Note: this could never be a valid expression because the thing to the left of
-// `?` is required to have type `bool`, and `f<a, b>` can only have type `Type`
-// or a function type.  But it is not the responsibility of the parser to report
-// an error here; that should be done by type analysis.
-var typeArgs_question = f<a, b> ? null : null;
-
-var typeArgs_question_period_methodInvocation = f<a, b>?.toString();
-var typeArgs_question_period_methodInvocation_generic = f<a, b>?.foo<c>();
-var typeArgs_question_period_period = f<a, b>?..toString();
-var typeArgs_question_period_propertyAccess = f<a, b>?.hashCode;
-var typeArgs_question_question = f<a, b> ?? 0;
 var typeArgs_semicolon = f<a, b>;
-var typeArgs_slash = f<a, b> / 1;
-var typeArgs_tilde_slash = f<a, b> ~/ 1;
 
 // The test cases called `operators_...` verify that `<` and `>` are treated as
 // operators when the `>` is not followed by one of the tokens:
 //
-//     ( ) ] } : ; , . ? == != .. ?. ?? ?..
-//     & | ^ + * %  / ~/
+//     ( . == != ) ] } ; : ,
 //
-// Unless otherwise noted, these test cases should not result in a parse error,
-// because they can be made into valid expressions through user-defined
-// operators.
+// Except as noted, these test cases should result in parse errors.
+
+var operators_ampersand = f(a<b,c>&d);
+
+// Note: this should not be a parse error since it is allowed to have an
+// identifier called `as`.
+var operators_as = f(a<b,c>as);
+
+var operators_asterisk = f(a<b,c>*d);
 
 // Note: this could never be a valid expression because the thing to the right
 // of `!` is required to have type `bool`, and the type of `[d]` will always be
@@ -72,15 +49,26 @@
 // error here; that should be done by type analysis.
 var operators_bang_openBracket = f(a<b,c>![d]);
 
+// Note: this should not be a parse error since `c` could have a type that
+// defines a `>` operator that accepts `bool`.
 var operators_bang_paren = f(a<b,c>!(d));
 
+var operators_bar = f(a<b,c>|d);
+var operators_caret = f(a<b,c>^d);
+var operators_is = f(a<b,c> is int);
+
 // Note: in principle we could parse this as a generic instantiation of a
 // generic instantiation, but since `<` is not one of the tokens that signals
 // `<` and `>` to be treated as type argument delimiters, the first pair of `<`
 // and `>` is treated as operators, and this results in a parse error.
 var operators_lessThan = f<a><b>;
 
+// Note: this should not be a parse error (indeed, this is valid if `a`, `b`,
+// `c`, and `d` are all of type `num`).
 var operators_minus = f(a<b,c>-d);
+
+// Note: this should not be a parse error since `c` could have a type that
+// defines a `>` operator that accepts `List`.
 var operators_openBracket = f(a<b,c>[d]);
 
 // Note: in principle we could parse `<b, c>` as type arguments, `[d]` as an
@@ -90,4 +78,18 @@
 // in a parse error.
 var operators_openBracket_error = f(a<b,c>[d]>e);
 
+// Note: this should not be a parse error since `c` could have a type that
+// defines a `>` operator that accepts `List`.
 var operators_openBracket_unambiguous = f(a<b,c>[d, e]);
+
+var operators_percent = f(a<b,c>%d);
+var operators_period_period = f(a<b,c>..toString());
+var operators_plus = f(a<b,c>+d);
+var operators_question = f(a<b,c> ? null : null);
+var operators_question_period_methodInvocation = f(a<b,c>?.toString());
+var operators_question_period_methodInvocation_generic = f(a<b,c>?.foo<c>());
+var operators_question_period_period = f(a<b,c>?..toString());
+var operators_question_period_propertyAccess = f(a<b,c>?.hashCode);
+var operators_question_question = f(a<b,c> ?? d);
+var operators_slash = f(a<b,c>/d);
+var operators_tilde_slash = f(a<b,c>~/d);
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
index 9e0f65c..eb3e565 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.expect
@@ -1,156 +1,91 @@
 Problems reported:
 
-parser/general/function_reference_following_token:81:29: A comparison expression can't be an operand of another comparison expression.
+parser/general/function_reference_following_token:38:35: Expected an identifier, but got '&'.
+var operators_ampersand = f(a<b,c>&d);
+                                  ^
+
+parser/general/function_reference_following_token:44:34: Expected an identifier, but got '*'.
+var operators_asterisk = f(a<b,c>*d);
+                                 ^
+
+parser/general/function_reference_following_token:56:29: Expected an identifier, but got '|'.
+var operators_bar = f(a<b,c>|d);
+                            ^
+
+parser/general/function_reference_following_token:57:31: Expected an identifier, but got '^'.
+var operators_caret = f(a<b,c>^d);
+                              ^
+
+parser/general/function_reference_following_token:58:29: Expected an identifier, but got 'is'.
+var operators_is = f(a<b,c> is int);
+                            ^^
+
+parser/general/function_reference_following_token:64:29: A comparison expression can't be an operand of another comparison expression.
 var operators_lessThan = f<a><b>;
                             ^
 
-parser/general/function_reference_following_token:81:33: Expected '[' before this.
+parser/general/function_reference_following_token:64:33: Expected '[' before this.
 var operators_lessThan = f<a><b>;
                                 ^
 
-parser/general/function_reference_following_token:91:46: A comparison expression can't be an operand of another comparison expression.
+parser/general/function_reference_following_token:79:46: A comparison expression can't be an operand of another comparison expression.
 var operators_openBracket_error = f(a<b,c>[d]>e);
                                              ^
 
+parser/general/function_reference_following_token:85:33: Expected an identifier, but got '%'.
+var operators_percent = f(a<b,c>%d);
+                                ^
+
+parser/general/function_reference_following_token:86:39: Expected an identifier, but got '..'.
+var operators_period_period = f(a<b,c>..toString());
+                                      ^^
+
+parser/general/function_reference_following_token:87:30: '+' is not a prefix operator.
+var operators_plus = f(a<b,c>+d);
+                             ^
+
+parser/general/function_reference_following_token:88:35: Expected an identifier, but got '?'.
+var operators_question = f(a<b,c> ? null : null);
+                                  ^
+
+parser/general/function_reference_following_token:89:58: Expected an identifier, but got '?.'.
+var operators_question_period_methodInvocation = f(a<b,c>?.toString());
+                                                         ^^
+
+parser/general/function_reference_following_token:90:66: Expected an identifier, but got '?.'.
+var operators_question_period_methodInvocation_generic = f(a<b,c>?.foo<c>());
+                                                                 ^^
+
+parser/general/function_reference_following_token:91:48: Expected an identifier, but got '?..'.
+var operators_question_period_period = f(a<b,c>?..toString());
+                                               ^^^
+
+parser/general/function_reference_following_token:91:51: Expected ',' before this.
+var operators_question_period_period = f(a<b,c>?..toString());
+                                                  ^^^^^^^^
+
+parser/general/function_reference_following_token:92:56: Expected an identifier, but got '?.'.
+var operators_question_period_propertyAccess = f(a<b,c>?.hashCode);
+                                                       ^^
+
+parser/general/function_reference_following_token:93:44: Expected an identifier, but got '??'.
+var operators_question_question = f(a<b,c> ?? d);
+                                           ^^
+
+parser/general/function_reference_following_token:94:31: Expected an identifier, but got '/'.
+var operators_slash = f(a<b,c>/d);
+                              ^
+
+parser/general/function_reference_following_token:95:37: Expected an identifier, but got '~/'.
+var operators_tilde_slash = f(a<b,c>~/d);
+                                    ^^
+
 beginCompilationUnit(var)
   beginMetadataStar(var)
   endMetadataStar(0)
   beginTopLevelMember(var)
     beginFields()
       handleNoType(var)
-      handleIdentifier(typeArgs_ampersand, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(&)
-          handleLiteralInt(0)
-        endBinaryExpression(&)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_as, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginAsOperatorType(as)
-          handleIdentifier(int, typeReference)
-          handleNoTypeArguments(;)
-          handleType(int, null)
-        endAsOperatorType(as)
-        handleAsOperator(as)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_asterisk, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(*)
-          handleLiteralInt(0)
-        endBinaryExpression(*)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_bar, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(|)
-          handleLiteralInt(0)
-        endBinaryExpression(|)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_caret, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(^)
-          handleLiteralInt(0)
-        endBinaryExpression(^)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
       handleIdentifier(typeArgs_closeBrace, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleNoTypeArguments({)
@@ -308,35 +243,6 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_is, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginIsOperatorType(is)
-          handleIdentifier(int, typeReference)
-          handleNoTypeArguments(;)
-          handleType(int, null)
-        endIsOperatorType(is)
-        handleIsOperator(is, null)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
       handleIdentifier(typeArgs_not_equals, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
@@ -385,32 +291,6 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_percent, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(%)
-          handleLiteralInt(0)
-        endBinaryExpression(%)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
       handleIdentifier(typeArgs_period_methodInvocation, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         beginImplicitCreationExpression(=)
@@ -470,37 +350,6 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_period_period, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginCascade(..)
-          handleIdentifier(toString, expressionContinuation)
-          handleNoTypeArguments(()
-          beginArguments(()
-          endArguments(0, (, ))
-          handleSend(toString, ;)
-          handleEndingBinaryExpression(..)
-        endCascade()
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
       handleIdentifier(typeArgs_period_propertyAccess, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
@@ -529,207 +378,6 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_plus, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(+)
-          handleLiteralInt(0)
-        endBinaryExpression(+)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginConditionalExpression(?)
-          handleLiteralNull(null)
-          handleConditionalExpressionColon()
-          handleLiteralNull(null)
-        endConditionalExpression(?, :)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question_period_methodInvocation, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        handleIdentifier(toString, expressionContinuation)
-        handleNoTypeArguments(()
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(toString, ;)
-        handleEndingBinaryExpression(?.)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question_period_methodInvocation_generic, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        handleIdentifier(foo, expressionContinuation)
-        beginTypeArguments(<)
-          handleIdentifier(c, typeReference)
-          handleNoTypeArguments(>)
-          handleType(c, null)
-        endTypeArguments(1, <, >)
-        beginArguments(()
-        endArguments(0, (, ))
-        handleSend(foo, ;)
-        handleEndingBinaryExpression(?.)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question_period_period, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginCascade(?..)
-          handleIdentifier(toString, expressionContinuation)
-          handleNoTypeArguments(()
-          beginArguments(()
-          endArguments(0, (, ))
-          handleSend(toString, ;)
-          handleEndingBinaryExpression(?..)
-        endCascade()
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question_period_propertyAccess, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        handleIdentifier(hashCode, expressionContinuation)
-        handleNoTypeArguments(;)
-        handleNoArguments(;)
-        handleSend(hashCode, ;)
-        handleEndingBinaryExpression(?.)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
-      handleIdentifier(typeArgs_question_question, topLevelVariableDeclaration)
-      beginFieldInitializer(=)
-        handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
-          handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(??)
-          handleLiteralInt(0)
-        endBinaryExpression(??)
-      endFieldInitializer(=, ;)
-    endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  endTopLevelDeclaration(var)
-  beginMetadataStar(var)
-  endMetadataStar(0)
-  beginTopLevelMember(var)
-    beginFields(;)
-      handleNoType(var)
       handleIdentifier(typeArgs_semicolon, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
@@ -753,24 +401,40 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_slash, topLevelVariableDeclaration)
+      handleIdentifier(operators_ampersand, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
           handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(/)
-          handleLiteralInt(1)
-        endBinaryExpression(/)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '&'., Try inserting an identifier before '&'., {lexeme: &}], &, &)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(&)
+            handleNoArguments(&)
+            handleSend(, &)
+            beginBinaryExpression(&)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(&)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
       endFieldInitializer(=, ;)
     endTopLevelFields(null, null, null, null, var, 1, var, ;)
   endTopLevelDeclaration(var)
@@ -779,24 +443,75 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
-      handleIdentifier(typeArgs_tilde_slash, topLevelVariableDeclaration)
+      handleIdentifier(operators_as, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
-        handleNoTypeArguments(<)
-        handleNoArguments(<)
-        handleSend(f, <)
-        beginTypeArguments(<)
-          handleIdentifier(a, typeReference)
-          handleNoTypeArguments(,)
-          handleType(a, null)
-          handleIdentifier(b, typeReference)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
           handleNoTypeArguments(>)
-          handleType(b, null)
-        endTypeArguments(2, <, >)
-        handleTypeArgumentApplication(<)
-        beginBinaryExpression(~/)
-          handleLiteralInt(1)
-        endBinaryExpression(~/)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleIdentifier(as, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(as, ))
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_asterisk, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '*'., Try inserting an identifier before '*'., {lexeme: *}], *, *)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(*)
+            handleNoArguments(*)
+            handleSend(, *)
+            beginBinaryExpression(*)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(*)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
       endFieldInitializer(=, ;)
     endTopLevelFields(null, null, null, null, var, 1, var, ;)
   endTopLevelDeclaration(var)
@@ -880,6 +595,132 @@
   beginTopLevelMember(var)
     beginFields(;)
       handleNoType(var)
+      handleIdentifier(operators_bar, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '|'., Try inserting an identifier before '|'., {lexeme: |}], |, |)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(|)
+            handleNoArguments(|)
+            handleSend(, |)
+            beginBinaryExpression(|)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(|)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_caret, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '^'., Try inserting an identifier before '^'., {lexeme: ^}], ^, ^)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(^)
+            handleNoArguments(^)
+            handleSend(, ^)
+            beginBinaryExpression(^)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(^)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_is, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got 'is'., Try inserting an identifier before 'is'., {lexeme: is}], is, is)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(is)
+            handleNoArguments(is)
+            handleSend(, is)
+          endBinaryExpression(>)
+          beginIsOperatorType(is)
+            handleIdentifier(int, typeReference)
+            handleNoTypeArguments())
+            handleType(int, null)
+          endIsOperatorType(is)
+          handleIsOperator(is, null)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
       handleIdentifier(operators_lessThan, topLevelVariableDeclaration)
       beginFieldInitializer(=)
         handleIdentifier(f, expression)
@@ -1062,5 +903,471 @@
         handleSend(f, ;)
       endFieldInitializer(=, ;)
     endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_percent, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '%'., Try inserting an identifier before '%'., {lexeme: %}], %, %)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(%)
+            handleNoArguments(%)
+            handleSend(, %)
+            beginBinaryExpression(%)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(%)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_period_period, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '..'., Try inserting an identifier before '..'., {lexeme: ..}], .., ..)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(..)
+            handleNoArguments(..)
+            handleSend(, ..)
+          endBinaryExpression(>)
+          beginCascade(..)
+            handleIdentifier(toString, expressionContinuation)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(toString, ))
+            handleEndingBinaryExpression(..)
+          endCascade()
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_plus, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(UnsupportedPrefixPlus, +, +)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(+)
+            handleNoArguments(+)
+            handleSend(, +)
+            beginBinaryExpression(+)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(+)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '?'., Try inserting an identifier before '?'., {lexeme: ?}], ?, ?)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(?)
+            handleNoArguments(?)
+            handleSend(, ?)
+          endBinaryExpression(>)
+          beginConditionalExpression(?)
+            handleLiteralNull(null)
+            handleConditionalExpressionColon()
+            handleLiteralNull(null)
+          endConditionalExpression(?, :)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question_period_methodInvocation, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '?.'., Try inserting an identifier before '?.'., {lexeme: ?.}], ?., ?.)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(?.)
+            handleNoArguments(?.)
+            handleSend(, ?.)
+            handleIdentifier(toString, expressionContinuation)
+            handleNoTypeArguments(()
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(toString, ))
+            handleEndingBinaryExpression(?.)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question_period_methodInvocation_generic, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '?.'., Try inserting an identifier before '?.'., {lexeme: ?.}], ?., ?.)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(?.)
+            handleNoArguments(?.)
+            handleSend(, ?.)
+            handleIdentifier(foo, expressionContinuation)
+            beginTypeArguments(<)
+              handleIdentifier(c, typeReference)
+              handleNoTypeArguments(>)
+              handleType(c, null)
+            endTypeArguments(1, <, >)
+            beginArguments(()
+            endArguments(0, (, ))
+            handleSend(foo, ))
+            handleEndingBinaryExpression(?.)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question_period_period, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '?..'., Try inserting an identifier before '?..'., {lexeme: ?..}], ?.., ?..)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(toString)
+            handleNoArguments(toString)
+            handleSend(, toString)
+          endBinaryExpression(>)
+          handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], toString, toString)
+          handleIdentifier(toString, expression)
+          handleNoTypeArguments(()
+          beginArguments(()
+          endArguments(0, (, ))
+          handleSend(toString, ))
+        endArguments(3, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question_period_propertyAccess, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '?.'., Try inserting an identifier before '?.'., {lexeme: ?.}], ?., ?.)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(?.)
+            handleNoArguments(?.)
+            handleSend(, ?.)
+            handleIdentifier(hashCode, expressionContinuation)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(hashCode, ))
+            handleEndingBinaryExpression(?.)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_question_question, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '??'., Try inserting an identifier before '??'., {lexeme: ??}], ??, ??)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(??)
+            handleNoArguments(??)
+            handleSend(, ??)
+          endBinaryExpression(>)
+          beginBinaryExpression(??)
+            handleIdentifier(d, expression)
+            handleNoTypeArguments())
+            handleNoArguments())
+            handleSend(d, ))
+          endBinaryExpression(??)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_slash, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '/'., Try inserting an identifier before '/'., {lexeme: /}], /, /)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(/)
+            handleNoArguments(/)
+            handleSend(, /)
+            beginBinaryExpression(/)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(/)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  endTopLevelDeclaration(var)
+  beginMetadataStar(var)
+  endMetadataStar(0)
+  beginTopLevelMember(var)
+    beginFields(;)
+      handleNoType(var)
+      handleIdentifier(operators_tilde_slash, topLevelVariableDeclaration)
+      beginFieldInitializer(=)
+        handleIdentifier(f, expression)
+        handleNoTypeArguments(()
+        beginArguments(()
+          handleIdentifier(a, expression)
+          handleNoTypeArguments(<)
+          handleNoArguments(<)
+          handleSend(a, <)
+          beginBinaryExpression(<)
+            handleIdentifier(b, expression)
+            handleNoTypeArguments(,)
+            handleNoArguments(,)
+            handleSend(b, ,)
+          endBinaryExpression(<)
+          handleIdentifier(c, expression)
+          handleNoTypeArguments(>)
+          handleNoArguments(>)
+          handleSend(c, >)
+          beginBinaryExpression(>)
+            handleRecoverableError(Message[ExpectedIdentifier, Expected an identifier, but got '~/'., Try inserting an identifier before '~/'., {lexeme: ~/}], ~/, ~/)
+            handleIdentifier(, expression)
+            handleNoTypeArguments(~/)
+            handleNoArguments(~/)
+            handleSend(, ~/)
+            beginBinaryExpression(~/)
+              handleIdentifier(d, expression)
+              handleNoTypeArguments())
+              handleNoArguments())
+              handleSend(d, ))
+            endBinaryExpression(~/)
+          endBinaryExpression(>)
+        endArguments(2, (, ))
+        handleSend(f, ;)
+      endFieldInitializer(=, ;)
+    endTopLevelFields(null, null, null, null, var, 1, var, ;)
   endTopLevelDeclaration()
 endCompilationUnit(36, )
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
index dff1e80..ffafde7 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.intertwined.expect
@@ -8,237 +8,10 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl()
       listener: beginTopLevelMember(var)
-      parseFields(, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_ampersand, DeclarationKind.TopLevel, null, false)
+      parseFields(, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_closeBrace, DeclarationKind.TopLevel, null, false)
         listener: beginFields()
         listener: handleNoType(var)
         ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_ampersand, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_ampersand, typeArgs_ampersand, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(&)
-              parsePrecedenceExpression(&, 12, true)
-                parseUnaryExpression(&, true)
-                  parsePrimary(&, expression)
-                    parseLiteralInt(&)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(&)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_as, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_as, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_as, typeArgs_as, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parseAsOperatorRest(>)
-                listener: beginAsOperatorType(as)
-                computeTypeAfterIsOrAs(as)
-                listener: handleIdentifier(int, typeReference)
-                listener: handleNoTypeArguments(;)
-                listener: handleType(int, null)
-                listener: endAsOperatorType(as)
-                listener: handleAsOperator(as)
-                skipChainedAsIsOperators(int)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_asterisk, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_asterisk, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_asterisk, typeArgs_asterisk, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(*)
-              parsePrecedenceExpression(*, 15, true)
-                parseUnaryExpression(*, true)
-                  parsePrimary(*, expression)
-                    parseLiteralInt(*)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(*)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_bar, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_bar, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_bar, typeArgs_bar, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(|)
-              parsePrecedenceExpression(|, 10, true)
-                parseUnaryExpression(|, true)
-                  parsePrimary(|, expression)
-                    parseLiteralInt(|)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(|)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_caret, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_caret, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_caret, typeArgs_caret, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(^)
-              parsePrecedenceExpression(^, 11, true)
-                parseUnaryExpression(^, true)
-                  parsePrimary(^, expression)
-                    parseLiteralInt(^)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(^)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_closeBrace, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
           listener: handleIdentifier(typeArgs_closeBrace, topLevelVariableDeclaration)
         parseFieldInitializerOpt(typeArgs_closeBrace, typeArgs_closeBrace, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
@@ -528,53 +301,6 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_is, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_is, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_is, typeArgs_is, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parseIsOperatorRest(>)
-                listener: beginIsOperatorType(is)
-                computeTypeAfterIsOrAs(is)
-                listener: handleIdentifier(int, typeReference)
-                listener: handleNoTypeArguments(;)
-                listener: handleType(int, null)
-                listener: endIsOperatorType(is)
-                listener: handleIsOperator(is, null)
-                skipChainedAsIsOperators(int)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
       parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_not_equals, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
@@ -660,51 +386,6 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_percent, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_percent, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_percent, typeArgs_percent, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(%)
-              parsePrecedenceExpression(%, 15, true)
-                parseUnaryExpression(%, true)
-                  parsePrimary(%, expression)
-                    parseLiteralInt(%)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(%)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
       parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_period_methodInvocation, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
@@ -804,60 +485,6 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_period_period, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_period_period, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_period_period, typeArgs_period_period, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parseCascadeExpression(>)
-                listener: beginCascade(..)
-                parseSend(.., expressionContinuation)
-                  isNextIdentifier(..)
-                  ensureIdentifier(.., expressionContinuation)
-                    listener: handleIdentifier(toString, expressionContinuation)
-                  listener: handleNoTypeArguments(()
-                  parseArgumentsOpt(toString)
-                    parseArguments(toString)
-                      parseArgumentsRest(()
-                        listener: beginArguments(()
-                        listener: endArguments(0, (, ))
-                  listener: handleSend(toString, ;)
-                listener: handleEndingBinaryExpression(..)
-                parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
-                listener: endCascade()
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
       parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_period_propertyAccess, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
@@ -907,364 +534,6 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_plus, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_plus, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_plus, typeArgs_plus, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(+)
-              parsePrecedenceExpression(+, 14, true)
-                parseUnaryExpression(+, true)
-                  parsePrimary(+, expression)
-                    parseLiteralInt(+)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(+)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question, typeArgs_question, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parseConditionalExpressionRest(>)
-                listener: beginConditionalExpression(?)
-                parseExpressionWithoutCascade(?)
-                  parsePrecedenceExpression(?, 1, false)
-                    parseUnaryExpression(?, false)
-                      parsePrimary(?, expression)
-                        parseLiteralNull(?)
-                          listener: handleLiteralNull(null)
-                ensureColon(null)
-                listener: handleConditionalExpressionColon()
-                parseExpressionWithoutCascade(:)
-                  parsePrecedenceExpression(:, 1, false)
-                    parseUnaryExpression(:, false)
-                      parsePrimary(:, expression)
-                        parseLiteralNull(:)
-                          listener: handleLiteralNull(null)
-                listener: endConditionalExpression(?, :)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question_period_methodInvocation, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question_period_methodInvocation, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question_period_methodInvocation, typeArgs_question_period_methodInvocation, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parsePrimary(?., expressionContinuation)
-                parseSendOrFunctionLiteral(?., expressionContinuation)
-                  looksLikeFunctionBody(;)
-                  parseSend(?., expressionContinuation)
-                    isNextIdentifier(?.)
-                    ensureIdentifier(?., expressionContinuation)
-                      listener: handleIdentifier(toString, expressionContinuation)
-                    listener: handleNoTypeArguments(()
-                    parseArgumentsOpt(toString)
-                      parseArguments(toString)
-                        parseArgumentsRest(()
-                          listener: beginArguments(()
-                          listener: endArguments(0, (, ))
-                    listener: handleSend(toString, ;)
-              listener: handleEndingBinaryExpression(?.)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question_period_methodInvocation_generic, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question_period_methodInvocation_generic, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question_period_methodInvocation_generic, typeArgs_question_period_methodInvocation_generic, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parsePrimary(?., expressionContinuation)
-                parseSendOrFunctionLiteral(?., expressionContinuation)
-                  looksLikeFunctionBody(;)
-                  parseSend(?., expressionContinuation)
-                    isNextIdentifier(?.)
-                    ensureIdentifier(?., expressionContinuation)
-                      listener: handleIdentifier(foo, expressionContinuation)
-                    listener: beginTypeArguments(<)
-                    listener: handleIdentifier(c, typeReference)
-                    listener: handleNoTypeArguments(>)
-                    listener: handleType(c, null)
-                    listener: endTypeArguments(1, <, >)
-                    parseArgumentsOpt(>)
-                      parseArguments(>)
-                        parseArgumentsRest(()
-                          listener: beginArguments(()
-                          listener: endArguments(0, (, ))
-                    listener: handleSend(foo, ;)
-              listener: handleEndingBinaryExpression(?.)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question_period_period, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question_period_period, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question_period_period, typeArgs_question_period_period, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parseCascadeExpression(>)
-                listener: beginCascade(?..)
-                parseSend(?.., expressionContinuation)
-                  isNextIdentifier(?..)
-                  ensureIdentifier(?.., expressionContinuation)
-                    listener: handleIdentifier(toString, expressionContinuation)
-                  listener: handleNoTypeArguments(()
-                  parseArgumentsOpt(toString)
-                    parseArguments(toString)
-                      parseArgumentsRest(()
-                        listener: beginArguments(()
-                        listener: endArguments(0, (, ))
-                  listener: handleSend(toString, ;)
-                listener: handleEndingBinaryExpression(?..)
-                parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
-                listener: endCascade()
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question_period_propertyAccess, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question_period_propertyAccess, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question_period_propertyAccess, typeArgs_question_period_propertyAccess, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              parsePrimary(?., expressionContinuation)
-                parseSendOrFunctionLiteral(?., expressionContinuation)
-                  parseSend(?., expressionContinuation)
-                    isNextIdentifier(?.)
-                    ensureIdentifier(?., expressionContinuation)
-                      listener: handleIdentifier(hashCode, expressionContinuation)
-                    listener: handleNoTypeArguments(;)
-                    parseArgumentsOpt(hashCode)
-                      listener: handleNoArguments(;)
-                    listener: handleSend(hashCode, ;)
-              listener: handleEndingBinaryExpression(?.)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_question_question, DeclarationKind.TopLevel, null, false)
-        listener: beginFields(;)
-        listener: handleNoType(var)
-        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_question_question, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_question_question, typeArgs_question_question, null, null, null, var, DeclarationKind.TopLevel, null)
-          listener: beginFieldInitializer(=)
-          parseExpression(=)
-            parsePrecedenceExpression(=, 1, true)
-              parseUnaryExpression(=, true)
-                parsePrimary(=, expression)
-                  parseSendOrFunctionLiteral(=, expression)
-                    parseSend(=, expression)
-                      isNextIdentifier(=)
-                      ensureIdentifier(=, expression)
-                        listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
-                      parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(??)
-              parsePrecedenceExpression(??, 5, true)
-                parseUnaryExpression(??, true)
-                  parsePrimary(??, expression)
-                    parseLiteralInt(??)
-                      listener: handleLiteralInt(0)
-              listener: endBinaryExpression(??)
-          listener: endFieldInitializer(=, ;)
-        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
-  listener: endTopLevelDeclaration(var)
-  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
-    parseMetadataStar(;)
-      listener: beginMetadataStar(var)
-      listener: endMetadataStar(0)
-    parseTopLevelMemberImpl(;)
-      listener: beginTopLevelMember(var)
       parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_semicolon, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
@@ -1303,42 +572,100 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_slash, DeclarationKind.TopLevel, null, false)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_ampersand, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
         ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_slash, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_slash, typeArgs_slash, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: handleIdentifier(operators_ampersand, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_ampersand, operators_ampersand, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
             parsePrecedenceExpression(=, 1, true)
               parseUnaryExpression(=, true)
                 parsePrimary(=, expression)
                   parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
                     parseSend(=, expression)
                       isNextIdentifier(=)
                       ensureIdentifier(=, expression)
                         listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
+                      listener: handleNoTypeArguments(()
                       parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(/)
-              parsePrecedenceExpression(/, 15, true)
-                parseUnaryExpression(/, true)
-                  parsePrimary(/, expression)
-                    parseLiteralInt(/)
-                      listener: handleLiteralInt(1)
-              listener: endBinaryExpression(/)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: &}], &, &)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(&)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(&)
+                                        listener: handleSend(, &)
+                                  listener: beginBinaryExpression(&)
+                                  parsePrecedenceExpression(&, 12, true)
+                                    parseUnaryExpression(&, true)
+                                      parsePrimary(&, expression)
+                                        parseSendOrFunctionLiteral(&, expression)
+                                          parseSend(&, expression)
+                                            isNextIdentifier(&)
+                                            ensureIdentifier(&, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(&)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
           listener: endFieldInitializer(=, ;)
         listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
   listener: endTopLevelDeclaration(var)
@@ -1348,42 +675,189 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
-      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', typeArgs_tilde_slash, DeclarationKind.TopLevel, null, false)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_as, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
         ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
-          listener: handleIdentifier(typeArgs_tilde_slash, topLevelVariableDeclaration)
-        parseFieldInitializerOpt(typeArgs_tilde_slash, typeArgs_tilde_slash, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: handleIdentifier(operators_as, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_as, operators_as, null, null, null, var, DeclarationKind.TopLevel, null)
           listener: beginFieldInitializer(=)
           parseExpression(=)
             parsePrecedenceExpression(=, 1, true)
               parseUnaryExpression(=, true)
                 parsePrimary(=, expression)
                   parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
                     parseSend(=, expression)
                       isNextIdentifier(=)
                       ensureIdentifier(=, expression)
                         listener: handleIdentifier(f, expression)
-                      listener: handleNoTypeArguments(<)
+                      listener: handleNoTypeArguments(()
                       parseArgumentsOpt(f)
-                        listener: handleNoArguments(<)
-                      listener: handleSend(f, <)
-              listener: beginTypeArguments(<)
-              listener: handleIdentifier(a, typeReference)
-              listener: handleNoTypeArguments(,)
-              listener: handleType(a, null)
-              listener: handleIdentifier(b, typeReference)
-              listener: handleNoTypeArguments(>)
-              listener: handleType(b, null)
-              listener: endTypeArguments(2, <, >)
-              listener: handleTypeArgumentApplication(<)
-              listener: beginBinaryExpression(~/)
-              parsePrecedenceExpression(~/, 15, true)
-                parseUnaryExpression(~/, true)
-                  parsePrimary(~/, expression)
-                    parseLiteralInt(~/)
-                      listener: handleLiteralInt(1)
-              listener: endBinaryExpression(~/)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  parseUnaryExpression(>, true)
+                                    parsePrimary(>, expression)
+                                      inPlainSync()
+                                      parseSendOrFunctionLiteral(>, expression)
+                                        parseSend(>, expression)
+                                          isNextIdentifier(>)
+                                          ensureIdentifier(>, expression)
+                                            inPlainSync()
+                                            listener: handleIdentifier(as, expression)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(as)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(as, ))
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_asterisk, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_asterisk, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_asterisk, operators_asterisk, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: *}], *, *)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(*)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(*)
+                                        listener: handleSend(, *)
+                                  listener: beginBinaryExpression(*)
+                                  parsePrecedenceExpression(*, 15, true)
+                                    parseUnaryExpression(*, true)
+                                      parsePrimary(*, expression)
+                                        parseSendOrFunctionLiteral(*, expression)
+                                          parseSend(*, expression)
+                                            isNextIdentifier(*)
+                                            ensureIdentifier(*, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(*)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
           listener: endFieldInitializer(=, ;)
         listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
   listener: endTopLevelDeclaration(var)
@@ -1590,6 +1064,311 @@
       listener: endMetadataStar(0)
     parseTopLevelMemberImpl(;)
       listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_bar, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_bar, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_bar, operators_bar, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: |}], |, |)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(|)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(|)
+                                        listener: handleSend(, |)
+                                  listener: beginBinaryExpression(|)
+                                  parsePrecedenceExpression(|, 10, true)
+                                    parseUnaryExpression(|, true)
+                                      parsePrimary(|, expression)
+                                        parseSendOrFunctionLiteral(|, expression)
+                                          parseSend(|, expression)
+                                            isNextIdentifier(|)
+                                            ensureIdentifier(|, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(|)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_caret, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_caret, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_caret, operators_caret, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ^}], ^, ^)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(^)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(^)
+                                        listener: handleSend(, ^)
+                                  listener: beginBinaryExpression(^)
+                                  parsePrecedenceExpression(^, 11, true)
+                                    parseUnaryExpression(^, true)
+                                      parsePrimary(^, expression)
+                                        parseSendOrFunctionLiteral(^, expression)
+                                          parseSend(^, expression)
+                                            isNextIdentifier(^)
+                                            ensureIdentifier(^, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(^)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_is, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_is, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_is, operators_is, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  parseUnaryExpression(>, true)
+                                    parsePrimary(>, expression)
+                                      inPlainSync()
+                                      parseSend(>, expression)
+                                        isNextIdentifier(>)
+                                        ensureIdentifier(>, 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)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(is)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(is)
+                                        listener: handleSend(, is)
+                                listener: endBinaryExpression(>)
+                                parseIsOperatorRest()
+                                  listener: beginIsOperatorType(is)
+                                  computeTypeAfterIsOrAs(is)
+                                  listener: handleIdentifier(int, typeReference)
+                                  listener: handleNoTypeArguments())
+                                  listener: handleType(int, null)
+                                  listener: endIsOperatorType(is)
+                                  listener: handleIsOperator(is, null)
+                                  skipChainedAsIsOperators(int)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
       parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_lessThan, DeclarationKind.TopLevel, null, false)
         listener: beginFields(;)
         listener: handleNoType(var)
@@ -2048,6 +1827,1156 @@
                       listener: handleSend(f, ;)
           listener: endFieldInitializer(=, ;)
         listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_percent, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_percent, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_percent, operators_percent, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: %}], %, %)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(%)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(%)
+                                        listener: handleSend(, %)
+                                  listener: beginBinaryExpression(%)
+                                  parsePrecedenceExpression(%, 15, true)
+                                    parseUnaryExpression(%, true)
+                                      parsePrimary(%, expression)
+                                        parseSendOrFunctionLiteral(%, expression)
+                                          parseSend(%, expression)
+                                            isNextIdentifier(%)
+                                            ensureIdentifier(%, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(%)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_period_period, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_period_period, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_period_period, operators_period_period, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ..}], .., ..)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(..)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(..)
+                                        listener: handleSend(, ..)
+                                listener: endBinaryExpression(>)
+                                parseCascadeExpression()
+                                  listener: beginCascade(..)
+                                  parseSend(.., expressionContinuation)
+                                    isNextIdentifier(..)
+                                    ensureIdentifier(.., expressionContinuation)
+                                      listener: handleIdentifier(toString, expressionContinuation)
+                                    listener: handleNoTypeArguments(()
+                                    parseArgumentsOpt(toString)
+                                      parseArguments(toString)
+                                        parseArgumentsRest(()
+                                          listener: beginArguments(()
+                                          listener: endArguments(0, (, ))
+                                    listener: handleSend(toString, ))
+                                  listener: handleEndingBinaryExpression(..)
+                                  parseArgumentOrIndexStar(), Instance of 'NoTypeParamOrArg', false)
+                                  listener: endCascade()
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_plus, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_plus, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_plus, operators_plus, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  parseUnaryExpression(>, true)
+                                    rewriteAndRecover(>, UnsupportedPrefixPlus, )
+                                      reportRecoverableError(+, UnsupportedPrefixPlus)
+                                        listener: handleRecoverableError(UnsupportedPrefixPlus, +, +)
+                                      rewriter()
+                                    parsePrimary(>, expression)
+                                      parseSendOrFunctionLiteral(>, expression)
+                                        parseSend(>, expression)
+                                          isNextIdentifier(>)
+                                          ensureIdentifier(>, expression)
+                                            listener: handleIdentifier(, expression)
+                                          listener: handleNoTypeArguments(+)
+                                          parseArgumentsOpt()
+                                            listener: handleNoArguments(+)
+                                          listener: handleSend(, +)
+                                  listener: beginBinaryExpression(+)
+                                  parsePrecedenceExpression(+, 14, true)
+                                    parseUnaryExpression(+, true)
+                                      parsePrimary(+, expression)
+                                        parseSendOrFunctionLiteral(+, expression)
+                                          parseSend(+, expression)
+                                            isNextIdentifier(+)
+                                            ensureIdentifier(+, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(+)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question, operators_question, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ?}], ?, ?)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(?)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(?)
+                                        listener: handleSend(, ?)
+                                listener: endBinaryExpression(>)
+                                parseConditionalExpressionRest()
+                                  listener: beginConditionalExpression(?)
+                                  parseExpressionWithoutCascade(?)
+                                    parsePrecedenceExpression(?, 1, false)
+                                      parseUnaryExpression(?, false)
+                                        parsePrimary(?, expression)
+                                          parseLiteralNull(?)
+                                            listener: handleLiteralNull(null)
+                                  ensureColon(null)
+                                  listener: handleConditionalExpressionColon()
+                                  parseExpressionWithoutCascade(:)
+                                    parsePrecedenceExpression(:, 1, false)
+                                      parseUnaryExpression(:, false)
+                                        parsePrimary(:, expression)
+                                          parseLiteralNull(:)
+                                            listener: handleLiteralNull(null)
+                                  listener: endConditionalExpression(?, :)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question_period_methodInvocation, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question_period_methodInvocation, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question_period_methodInvocation, operators_question_period_methodInvocation, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ?.}], ?., ?.)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(?.)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(?.)
+                                        listener: handleSend(, ?.)
+                                  parsePrimary(?., expressionContinuation)
+                                    parseSendOrFunctionLiteral(?., expressionContinuation)
+                                      looksLikeFunctionBody())
+                                      parseSend(?., expressionContinuation)
+                                        isNextIdentifier(?.)
+                                        ensureIdentifier(?., expressionContinuation)
+                                          listener: handleIdentifier(toString, expressionContinuation)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(toString)
+                                          parseArguments(toString)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(toString, ))
+                                  listener: handleEndingBinaryExpression(?.)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question_period_methodInvocation_generic, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question_period_methodInvocation_generic, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question_period_methodInvocation_generic, operators_question_period_methodInvocation_generic, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ?.}], ?., ?.)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(?.)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(?.)
+                                        listener: handleSend(, ?.)
+                                  parsePrimary(?., expressionContinuation)
+                                    parseSendOrFunctionLiteral(?., expressionContinuation)
+                                      looksLikeFunctionBody())
+                                      parseSend(?., expressionContinuation)
+                                        isNextIdentifier(?.)
+                                        ensureIdentifier(?., expressionContinuation)
+                                          listener: handleIdentifier(foo, expressionContinuation)
+                                        listener: beginTypeArguments(<)
+                                        listener: handleIdentifier(c, typeReference)
+                                        listener: handleNoTypeArguments(>)
+                                        listener: handleType(c, null)
+                                        listener: endTypeArguments(1, <, >)
+                                        parseArgumentsOpt(>)
+                                          parseArguments(>)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(foo, ))
+                                  listener: handleEndingBinaryExpression(?.)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question_period_period, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question_period_period, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question_period_period, operators_question_period_period, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ?..}], ?.., ?..)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(toString)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(toString)
+                                        listener: handleSend(, toString)
+                                listener: endBinaryExpression(>)
+                            rewriteAndRecover(, Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], ,)
+                              reportRecoverableError(toString, Message[ExpectedButGot, Expected ',' before this., null, {string: ,}])
+                                listener: handleRecoverableError(Message[ExpectedButGot, Expected ',' before this., null, {string: ,}], toString, toString)
+                              rewriter()
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      looksLikeFunctionBody())
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(toString, expression)
+                                        listener: handleNoTypeArguments(()
+                                        parseArgumentsOpt(toString)
+                                          parseArguments(toString)
+                                            parseArgumentsRest(()
+                                              listener: beginArguments(()
+                                              listener: endArguments(0, (, ))
+                                        listener: handleSend(toString, ))
+                            listener: endArguments(3, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question_period_propertyAccess, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question_period_propertyAccess, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question_period_propertyAccess, operators_question_period_propertyAccess, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ?.}], ?., ?.)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(?.)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(?.)
+                                        listener: handleSend(, ?.)
+                                  parsePrimary(?., expressionContinuation)
+                                    parseSendOrFunctionLiteral(?., expressionContinuation)
+                                      parseSend(?., expressionContinuation)
+                                        isNextIdentifier(?.)
+                                        ensureIdentifier(?., expressionContinuation)
+                                          listener: handleIdentifier(hashCode, expressionContinuation)
+                                        listener: handleNoTypeArguments())
+                                        parseArgumentsOpt(hashCode)
+                                          listener: handleNoArguments())
+                                        listener: handleSend(hashCode, ))
+                                  listener: handleEndingBinaryExpression(?.)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_question_question, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_question_question, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_question_question, operators_question_question, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ??}], ??, ??)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(??)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(??)
+                                        listener: handleSend(, ??)
+                                listener: endBinaryExpression(>)
+                                listener: beginBinaryExpression(??)
+                                parsePrecedenceExpression(??, 5, true)
+                                  parseUnaryExpression(??, true)
+                                    parsePrimary(??, expression)
+                                      parseSendOrFunctionLiteral(??, expression)
+                                        parseSend(??, expression)
+                                          isNextIdentifier(??)
+                                          ensureIdentifier(??, expression)
+                                            listener: handleIdentifier(d, expression)
+                                          listener: handleNoTypeArguments())
+                                          parseArgumentsOpt(d)
+                                            listener: handleNoArguments())
+                                          listener: handleSend(d, ))
+                                listener: endBinaryExpression(??)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_slash, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_slash, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_slash, operators_slash, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: /}], /, /)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(/)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(/)
+                                        listener: handleSend(, /)
+                                  listener: beginBinaryExpression(/)
+                                  parsePrecedenceExpression(/, 15, true)
+                                    parseUnaryExpression(/, true)
+                                      parsePrimary(/, expression)
+                                        parseSendOrFunctionLiteral(/, expression)
+                                          parseSend(/, expression)
+                                            isNextIdentifier(/)
+                                            ensureIdentifier(/, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(/)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
+  listener: endTopLevelDeclaration(var)
+  parseTopLevelDeclarationImpl(;, Instance of 'DirectiveContext')
+    parseMetadataStar(;)
+      listener: beginMetadataStar(var)
+      listener: endMetadataStar(0)
+    parseTopLevelMemberImpl(;)
+      listener: beginTopLevelMember(var)
+      parseFields(;, null, null, null, null, null, var, var, Instance of 'NoType', operators_tilde_slash, DeclarationKind.TopLevel, null, false)
+        listener: beginFields(;)
+        listener: handleNoType(var)
+        ensureIdentifierPotentiallyRecovered(var, topLevelVariableDeclaration, false)
+          listener: handleIdentifier(operators_tilde_slash, topLevelVariableDeclaration)
+        parseFieldInitializerOpt(operators_tilde_slash, operators_tilde_slash, null, null, null, var, DeclarationKind.TopLevel, null)
+          listener: beginFieldInitializer(=)
+          parseExpression(=)
+            parsePrecedenceExpression(=, 1, true)
+              parseUnaryExpression(=, true)
+                parsePrimary(=, expression)
+                  parseSendOrFunctionLiteral(=, expression)
+                    looksLikeFunctionBody(;)
+                    parseSend(=, expression)
+                      isNextIdentifier(=)
+                      ensureIdentifier(=, expression)
+                        listener: handleIdentifier(f, expression)
+                      listener: handleNoTypeArguments(()
+                      parseArgumentsOpt(f)
+                        parseArguments(f)
+                          parseArgumentsRest(()
+                            listener: beginArguments(()
+                            parseExpression(()
+                              parsePrecedenceExpression((, 1, true)
+                                parseUnaryExpression((, true)
+                                  parsePrimary((, expression)
+                                    parseSendOrFunctionLiteral((, expression)
+                                      parseSend((, expression)
+                                        isNextIdentifier(()
+                                        ensureIdentifier((, expression)
+                                          listener: handleIdentifier(a, expression)
+                                        listener: handleNoTypeArguments(<)
+                                        parseArgumentsOpt(a)
+                                          listener: handleNoArguments(<)
+                                        listener: handleSend(a, <)
+                                listener: beginBinaryExpression(<)
+                                parsePrecedenceExpression(<, 9, true)
+                                  parseUnaryExpression(<, true)
+                                    parsePrimary(<, expression)
+                                      parseSendOrFunctionLiteral(<, expression)
+                                        parseSend(<, expression)
+                                          isNextIdentifier(<)
+                                          ensureIdentifier(<, expression)
+                                            listener: handleIdentifier(b, expression)
+                                          listener: handleNoTypeArguments(,)
+                                          parseArgumentsOpt(b)
+                                            listener: handleNoArguments(,)
+                                          listener: handleSend(b, ,)
+                                listener: endBinaryExpression(<)
+                            parseExpression(,)
+                              parsePrecedenceExpression(,, 1, true)
+                                parseUnaryExpression(,, true)
+                                  parsePrimary(,, expression)
+                                    parseSendOrFunctionLiteral(,, expression)
+                                      parseSend(,, expression)
+                                        isNextIdentifier(,)
+                                        ensureIdentifier(,, expression)
+                                          listener: handleIdentifier(c, expression)
+                                        listener: handleNoTypeArguments(>)
+                                        parseArgumentsOpt(c)
+                                          listener: handleNoArguments(>)
+                                        listener: handleSend(c, >)
+                                listener: beginBinaryExpression(>)
+                                parsePrecedenceExpression(>, 9, true)
+                                  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: ~/}], ~/, ~/)
+                                          rewriter()
+                                          listener: handleIdentifier(, expression)
+                                        listener: handleNoTypeArguments(~/)
+                                        parseArgumentsOpt()
+                                          listener: handleNoArguments(~/)
+                                        listener: handleSend(, ~/)
+                                  listener: beginBinaryExpression(~/)
+                                  parsePrecedenceExpression(~/, 15, true)
+                                    parseUnaryExpression(~/, true)
+                                      parsePrimary(~/, expression)
+                                        parseSendOrFunctionLiteral(~/, expression)
+                                          parseSend(~/, expression)
+                                            isNextIdentifier(~/)
+                                            ensureIdentifier(~/, expression)
+                                              listener: handleIdentifier(d, expression)
+                                            listener: handleNoTypeArguments())
+                                            parseArgumentsOpt(d)
+                                              listener: handleNoArguments())
+                                            listener: handleSend(d, ))
+                                  listener: endBinaryExpression(~/)
+                                listener: endBinaryExpression(>)
+                            listener: endArguments(2, (, ))
+                      listener: handleSend(f, ;)
+          listener: endFieldInitializer(=, ;)
+        listener: endTopLevelFields(null, null, null, null, var, 1, var, ;)
   listener: endTopLevelDeclaration()
   reportAllErrorTokens(var)
   listener: endCompilationUnit(36, )
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.parser.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.parser.expect
index 0ccc331..9318b29 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.parser.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.parser.expect
@@ -1,48 +1,25 @@
 NOTICE: Stream was rewritten by parser!
 
-var typeArgs_ampersand = f<a, b> & 0;
-var typeArgs_as = f<a, b> as int;
-var typeArgs_asterisk = f<a, b> * 0;
-var typeArgs_bar = f<a, b> | 0;
-var typeArgs_caret = f<a, b> ^ 0;
 var typeArgs_closeBrace = {f<a, b>};
 var typeArgs_closeBracket = [f<a, b>];
 var typeArgs_closeParen = g(f<a, b>);
 var typeArgs_colon = {f<a, b>: null};
 var typeArgs_comma = [f<a, b>, null];
 var typeArgs_equals = f<a, b> == null;
-var typeArgs_is = f<a, b> is int;
 var typeArgs_not_equals = f<a, b> != null;
 
 
 
 var typeArgs_openParen = f<a, b>();
 
-var typeArgs_percent = f<a, b> % 0;
-
 
 
 var typeArgs_period_methodInvocation = f<a, b>.toString();
 
 var typeArgs_period_methodInvocation_generic = f<a, b>.foo<c>();
-var typeArgs_period_period = f<a, b>..toString();
 var typeArgs_period_propertyAccess = f<a, b>.hashCode;
-var typeArgs_plus = f<a, b> + 0;
 
-
-
-
-
-var typeArgs_question = f<a, b> ? null : null;
-
-var typeArgs_question_period_methodInvocation = f<a, b>?.toString();
-var typeArgs_question_period_methodInvocation_generic = f<a, b>?.foo<c>();
-var typeArgs_question_period_period = f<a, b>?..toString();
-var typeArgs_question_period_propertyAccess = f<a, b>?.hashCode;
-var typeArgs_question_question = f<a, b> ?? 0;
 var typeArgs_semicolon = f<a, b>;
-var typeArgs_slash = f<a, b> / 1;
-var typeArgs_tilde_slash = f<a, b> ~/ 1;
 
 
 
@@ -51,24 +28,40 @@
 
 
 
+var operators_ampersand = f(a<b,c>*synthetic*&d);
 
 
 
+var operators_as = f(a<b,c>as);
+
+var operators_asterisk = f(a<b,c>*synthetic**d);
+
 
 
 
 
 var operators_bang_openBracket = f(a<b,c>![d]);
 
+
+
 var operators_bang_paren = f(a<b,c>!(d));
 
+var operators_bar = f(a<b,c>*synthetic*|d);
+var operators_caret = f(a<b,c>*synthetic*^d);
+var operators_is = f(a<b,c> *synthetic*is int);
+
 
 
 
 
 var operators_lessThan = f<a><b>[];
 
+
+
 var operators_minus = f(a<b,c>-d);
+
+
+
 var operators_openBracket = f(a<b,c>[d]);
 
 
@@ -78,52 +71,43 @@
 
 var operators_openBracket_error = f(a<b,c>[d]>e);
 
+
+
 var operators_openBracket_unambiguous = f(a<b,c>[d, e]);
 
+var operators_percent = f(a<b,c>*synthetic*%d);
+var operators_period_period = f(a<b,c>*synthetic*..toString());
+var operators_plus = f(a<b,c>*synthetic*+d);
+var operators_question = f(a<b,c> *synthetic*? null : null);
+var operators_question_period_methodInvocation = f(a<b,c>*synthetic*?.toString());
+var operators_question_period_methodInvocation_generic = f(a<b,c>*synthetic*?.foo<c>());
+var operators_question_period_period = f(a<b,c>?..*synthetic*,toString());
+var operators_question_period_propertyAccess = f(a<b,c>*synthetic*?.hashCode);
+var operators_question_question = f(a<b,c> *synthetic*?? d);
+var operators_slash = f(a<b,c>*synthetic*/d);
+var operators_tilde_slash = f(a<b,c>*synthetic*~/d);
 
-var[KeywordToken] typeArgs_ampersand[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] &[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_as[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] as[KeywordToken] int[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_asterisk[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] *[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_bar[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] |[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_caret[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ^[SimpleToken] 0[StringToken];[SimpleToken]
+
 var[KeywordToken] typeArgs_closeBrace[StringToken] =[SimpleToken] {[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]}[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_closeBracket[StringToken] =[SimpleToken] [[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]][SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_closeParen[StringToken] =[SimpleToken] g[StringToken]([BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken])[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_colon[StringToken] =[SimpleToken] {[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]:[SimpleToken] null[KeywordToken]}[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_comma[StringToken] =[SimpleToken] [[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken],[SimpleToken] null[KeywordToken]][SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_equals[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ==[SimpleToken] null[KeywordToken];[SimpleToken]
-var[KeywordToken] typeArgs_is[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] is[KeywordToken] int[StringToken];[SimpleToken]
 var[KeywordToken] typeArgs_not_equals[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] !=[SimpleToken] null[KeywordToken];[SimpleToken]
 
 
 
 var[KeywordToken] typeArgs_openParen[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
 
-var[KeywordToken] typeArgs_percent[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] %[SimpleToken] 0[StringToken];[SimpleToken]
-
 
 
 var[KeywordToken] typeArgs_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
 
 var[KeywordToken] typeArgs_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_period_period[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_plus[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] +[SimpleToken] 0[StringToken];[SimpleToken]
 
-
-
-
-
-var[KeywordToken] typeArgs_question[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ?[SimpleToken] null[KeywordToken] :[SimpleToken] null[KeywordToken];[SimpleToken]
-
-var[KeywordToken] typeArgs_question_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_period[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]hashCode[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_question[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ??[SimpleToken] 0[StringToken];[SimpleToken]
 var[KeywordToken] typeArgs_semicolon[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_slash[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] /[SimpleToken] 1[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_tilde_slash[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ~/[SimpleToken] 1[StringToken];[SimpleToken]
 
 
 
@@ -132,24 +116,40 @@
 
 
 
+var[KeywordToken] operators_ampersand[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]&[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
 
 
 
+var[KeywordToken] operators_as[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]as[KeywordToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] operators_asterisk[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]*[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+
 
 
 
 
 var[KeywordToken] operators_bang_openBracket[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]![SimpleToken][[BeginToken]d[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_bang_paren[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]![SimpleToken]([BeginToken]d[StringToken])[SimpleToken])[SimpleToken];[SimpleToken]
 
+var[KeywordToken] operators_bar[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]|[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_caret[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]^[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_is[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] [SyntheticStringToken]is[KeywordToken] int[StringToken])[SimpleToken];[SimpleToken]
+
 
 
 
 
 var[KeywordToken] operators_lessThan[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken]>[SimpleToken]<[BeginToken]b[StringToken]>[SimpleToken][[SyntheticBeginToken]][SyntheticToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_minus[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]-[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+
+
+
 var[KeywordToken] operators_openBracket[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
 
 
@@ -159,5 +159,19 @@
 
 var[KeywordToken] operators_openBracket_error[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken]][SimpleToken]>[SimpleToken]e[StringToken])[SimpleToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_openBracket_unambiguous[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken],[SimpleToken] e[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] operators_percent[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]%[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_period_period[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_plus[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]+[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] [SyntheticStringToken]?[SimpleToken] null[KeywordToken] :[SimpleToken] null[KeywordToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]?.[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]?.[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_period[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]?..[SimpleToken][SyntheticStringToken],[SyntheticToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]?.[SimpleToken]hashCode[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_question[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] [SyntheticStringToken]??[SimpleToken] d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_slash[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]/[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_tilde_slash[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][SyntheticStringToken]~/[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
 [SimpleToken]
diff --git a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.scanner.expect b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.scanner.expect
index 44f7742..401acc1 100644
--- a/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.scanner.expect
+++ b/pkg/front_end/parser_testcases/general/function_reference_following_token.dart.scanner.expect
@@ -1,46 +1,23 @@
-var typeArgs_ampersand = f<a, b> & 0;
-var typeArgs_as = f<a, b> as int;
-var typeArgs_asterisk = f<a, b> * 0;
-var typeArgs_bar = f<a, b> | 0;
-var typeArgs_caret = f<a, b> ^ 0;
 var typeArgs_closeBrace = {f<a, b>};
 var typeArgs_closeBracket = [f<a, b>];
 var typeArgs_closeParen = g(f<a, b>);
 var typeArgs_colon = {f<a, b>: null};
 var typeArgs_comma = [f<a, b>, null];
 var typeArgs_equals = f<a, b> == null;
-var typeArgs_is = f<a, b> is int;
 var typeArgs_not_equals = f<a, b> != null;
 
 
 
 var typeArgs_openParen = f<a, b>();
 
-var typeArgs_percent = f<a, b> % 0;
-
 
 
 var typeArgs_period_methodInvocation = f<a, b>.toString();
 
 var typeArgs_period_methodInvocation_generic = f<a, b>.foo<c>();
-var typeArgs_period_period = f<a, b>..toString();
 var typeArgs_period_propertyAccess = f<a, b>.hashCode;
-var typeArgs_plus = f<a, b> + 0;
 
-
-
-
-
-var typeArgs_question = f<a, b> ? null : null;
-
-var typeArgs_question_period_methodInvocation = f<a, b>?.toString();
-var typeArgs_question_period_methodInvocation_generic = f<a, b>?.foo<c>();
-var typeArgs_question_period_period = f<a, b>?..toString();
-var typeArgs_question_period_propertyAccess = f<a, b>?.hashCode;
-var typeArgs_question_question = f<a, b> ?? 0;
 var typeArgs_semicolon = f<a, b>;
-var typeArgs_slash = f<a, b> / 1;
-var typeArgs_tilde_slash = f<a, b> ~/ 1;
 
 
 
@@ -49,24 +26,40 @@
 
 
 
+var operators_ampersand = f(a<b,c>&d);
 
 
 
+var operators_as = f(a<b,c>as);
+
+var operators_asterisk = f(a<b,c>*d);
+
 
 
 
 
 var operators_bang_openBracket = f(a<b,c>![d]);
 
+
+
 var operators_bang_paren = f(a<b,c>!(d));
 
+var operators_bar = f(a<b,c>|d);
+var operators_caret = f(a<b,c>^d);
+var operators_is = f(a<b,c> is int);
+
 
 
 
 
 var operators_lessThan = f<a><b>;
 
+
+
 var operators_minus = f(a<b,c>-d);
+
+
+
 var operators_openBracket = f(a<b,c>[d]);
 
 
@@ -76,52 +69,43 @@
 
 var operators_openBracket_error = f(a<b,c>[d]>e);
 
+
+
 var operators_openBracket_unambiguous = f(a<b,c>[d, e]);
 
+var operators_percent = f(a<b,c>%d);
+var operators_period_period = f(a<b,c>..toString());
+var operators_plus = f(a<b,c>+d);
+var operators_question = f(a<b,c> ? null : null);
+var operators_question_period_methodInvocation = f(a<b,c>?.toString());
+var operators_question_period_methodInvocation_generic = f(a<b,c>?.foo<c>());
+var operators_question_period_period = f(a<b,c>?..toString());
+var operators_question_period_propertyAccess = f(a<b,c>?.hashCode);
+var operators_question_question = f(a<b,c> ?? d);
+var operators_slash = f(a<b,c>/d);
+var operators_tilde_slash = f(a<b,c>~/d);
 
-var[KeywordToken] typeArgs_ampersand[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] &[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_as[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] as[KeywordToken] int[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_asterisk[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] *[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_bar[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] |[SimpleToken] 0[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_caret[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ^[SimpleToken] 0[StringToken];[SimpleToken]
+
 var[KeywordToken] typeArgs_closeBrace[StringToken] =[SimpleToken] {[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]}[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_closeBracket[StringToken] =[SimpleToken] [[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]][SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_closeParen[StringToken] =[SimpleToken] g[StringToken]([BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken])[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_colon[StringToken] =[SimpleToken] {[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]:[SimpleToken] null[KeywordToken]}[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_comma[StringToken] =[SimpleToken] [[BeginToken]f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken],[SimpleToken] null[KeywordToken]][SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_equals[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ==[SimpleToken] null[KeywordToken];[SimpleToken]
-var[KeywordToken] typeArgs_is[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] is[KeywordToken] int[StringToken];[SimpleToken]
 var[KeywordToken] typeArgs_not_equals[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] !=[SimpleToken] null[KeywordToken];[SimpleToken]
 
 
 
 var[KeywordToken] typeArgs_openParen[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
 
-var[KeywordToken] typeArgs_percent[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] %[SimpleToken] 0[StringToken];[SimpleToken]
-
 
 
 var[KeywordToken] typeArgs_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
 
 var[KeywordToken] typeArgs_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_period_period[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
 var[KeywordToken] typeArgs_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken].[SimpleToken]hashCode[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_plus[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] +[SimpleToken] 0[StringToken];[SimpleToken]
 
-
-
-
-
-var[KeywordToken] typeArgs_question[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ?[SimpleToken] null[KeywordToken] :[SimpleToken] null[KeywordToken];[SimpleToken]
-
-var[KeywordToken] typeArgs_question_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_period[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken]?.[SimpleToken]hashCode[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_question_question[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ??[SimpleToken] 0[StringToken];[SimpleToken]
 var[KeywordToken] typeArgs_semicolon[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken];[SimpleToken]
-var[KeywordToken] typeArgs_slash[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] /[SimpleToken] 1[StringToken];[SimpleToken]
-var[KeywordToken] typeArgs_tilde_slash[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken],[SimpleToken] b[StringToken]>[SimpleToken] ~/[SimpleToken] 1[StringToken];[SimpleToken]
 
 
 
@@ -130,24 +114,40 @@
 
 
 
+var[KeywordToken] operators_ampersand[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]&[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
 
 
 
+var[KeywordToken] operators_as[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]as[KeywordToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] operators_asterisk[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]*[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+
 
 
 
 
 var[KeywordToken] operators_bang_openBracket[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]![SimpleToken][[BeginToken]d[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_bang_paren[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]![SimpleToken]([BeginToken]d[StringToken])[SimpleToken])[SimpleToken];[SimpleToken]
 
+var[KeywordToken] operators_bar[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]|[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_caret[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]^[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_is[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] is[KeywordToken] int[StringToken])[SimpleToken];[SimpleToken]
+
 
 
 
 
 var[KeywordToken] operators_lessThan[StringToken] =[SimpleToken] f[StringToken]<[BeginToken]a[StringToken]>[SimpleToken]<[BeginToken]b[StringToken]>[SimpleToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_minus[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]-[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+
+
+
 var[KeywordToken] operators_openBracket[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
 
 
@@ -157,5 +157,19 @@
 
 var[KeywordToken] operators_openBracket_error[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken]][SimpleToken]>[SimpleToken]e[StringToken])[SimpleToken];[SimpleToken]
 
+
+
 var[KeywordToken] operators_openBracket_unambiguous[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken][[BeginToken]d[StringToken],[SimpleToken] e[StringToken]][SimpleToken])[SimpleToken];[SimpleToken]
+
+var[KeywordToken] operators_percent[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]%[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_period_period[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_plus[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]+[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] ?[SimpleToken] null[KeywordToken] :[SimpleToken] null[KeywordToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_methodInvocation[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]?.[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_methodInvocation_generic[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]?.[SimpleToken]foo[StringToken]<[BeginToken]c[StringToken]>[SimpleToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_period[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]?..[SimpleToken]toString[StringToken]([BeginToken])[SimpleToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_period_propertyAccess[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]?.[SimpleToken]hashCode[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_question_question[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken] ??[SimpleToken] d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_slash[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]/[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
+var[KeywordToken] operators_tilde_slash[StringToken] =[SimpleToken] f[StringToken]([BeginToken]a[StringToken]<[BeginToken]b[StringToken],[SimpleToken]c[StringToken]>[SimpleToken]~/[SimpleToken]d[StringToken])[SimpleToken];[SimpleToken]
 [SimpleToken]
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index ea6bf68..69aec91 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -142,6 +142,7 @@
 bsd
 bslash
 buffered
+buggy
 builder`s
 bulk
 bump
@@ -559,6 +560,7 @@
 i2b
 ic
 id
+ideal
 identifies
 identifying
 ideographic
@@ -1260,6 +1262,7 @@
 tflite
 th
 therein
+they'll
 thought
 ti
 tick
diff --git a/pkg/nnbd_migration/lib/src/decorated_type_operations.dart b/pkg/nnbd_migration/lib/src/decorated_type_operations.dart
index 3f38ca4..a93fa35 100644
--- a/pkg/nnbd_migration/lib/src/decorated_type_operations.dart
+++ b/pkg/nnbd_migration/lib/src/decorated_type_operations.dart
@@ -4,6 +4,7 @@
 
 import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_system.dart';
 import 'package:nnbd_migration/src/decorated_type.dart';
 import 'package:nnbd_migration/src/edge_origin.dart';
@@ -86,6 +87,10 @@
   }
 
   @override
+  bool isTypeParameterType(DecoratedType type) =>
+      type.type is TypeParameterType;
+
+  @override
   DecoratedType promoteToNonNull(DecoratedType type) {
     return type.withNode(_graph.never);
   }
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index d155843..62cd9a3 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -377,10 +377,14 @@
     var previousAssignedVariables = _assignedVariables;
     if (_flowAnalysis == null) {
       _assignedVariables = AssignedVariables();
+      // Note: we are using flow analysis to help us track true nullabilities;
+      // it's not necessary to replicate old bugs.  So we pass `true` for
+      // `respectImplicitlyTypedVarInitializers`.
       _flowAnalysis = FlowAnalysis<AstNode, Statement, Expression,
               PromotableElement, DecoratedType>(
           DecoratedTypeOperations(_typeSystem, _variables, _graph),
-          _assignedVariables!);
+          _assignedVariables!,
+          respectImplicitlyTypedVarInitializers: true);
     }
     try {
       _dispatch(node.name);
@@ -2110,10 +2114,14 @@
     assert(_assignedVariables == null);
     _assignedVariables =
         FlowAnalysisHelper.computeAssignedVariables(node, parameters);
+    // Note: we are using flow analysis to help us track true nullabilities;
+    // it's not necessary to replicate old bugs.  So we pass `true` for
+    // `respectImplicitlyTypedVarInitializers`.
     _flowAnalysis = FlowAnalysis<AstNode, Statement, Expression,
             PromotableElement, DecoratedType>(
         DecoratedTypeOperations(_typeSystem, _variables, _graph),
-        _assignedVariables!);
+        _assignedVariables!,
+        respectImplicitlyTypedVarInitializers: true);
     if (parameters != null) {
       for (var parameter in parameters.parameters) {
         _flowAnalysis!.declare(parameter.declaredElement!, true);
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index cf136cc..5634a76 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -315,9 +315,15 @@
     Constant? constantValue;
     bool isInt = false;
 
-    final nullable = type is NullableType;
+    // Note: the explicit type `bool` is needed because the checked-in version
+    // of the CFE that we use for bootstrapping doesn't yet have constructor
+    // tearoffs enabled, and the fix for bug
+    // https://github.com/dart-lang/language/issues/1785 only takes effect when
+    // constructor tearoffs are enabled.  TODO(paulberry): remove the type after
+    // the bootstrap CFE enables constructor tearoffs.
+    final bool nullable = type is NullableType;
     if (nullable) {
-      type = (type as NullableType).baseType;
+      type = type.baseType;
     }
 
     if (nullable && type == const EmptyType()) {
diff --git a/tests/language/nnbd/flow_analysis/local_boolean_implicitly_typed_new_test.dart b/tests/language/nnbd/flow_analysis/local_boolean_implicitly_typed_new_test.dart
new file mode 100644
index 0000000..5fd4721
--- /dev/null
+++ b/tests/language/nnbd/flow_analysis/local_boolean_implicitly_typed_new_test.dart
@@ -0,0 +1,202 @@
+// 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 file.
+
+// SharedOptions=--enable-experiment=constructor-tearoffs
+
+import '../../static_type_helper.dart';
+
+// This test checks whether a local boolean variable can be used to perform type
+// promotion, if that variable is implicitly typed.
+//
+// This test confirms that once the "constructor tearoffs" language feature is
+// enabled, initializer expressions on implicitly typed variables are no longer
+// ignored for the purposes of type promotion
+// (i.e. https://github.com/dart-lang/language/issues/1785 is fixed).
+
+parameterUnmodified(int? x) {
+  {
+    late final b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    late var b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+}
+
+parameterModifiedLater(int? x, int? y) {
+  x = y;
+  {
+    late final b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    late var b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+}
+
+localVariableInitialized(int? y) {
+  int? x = y;
+  {
+    late final b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    late var b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+}
+
+localVariableModifiedLater(int? y) {
+  int? x;
+  x = y;
+  {
+    late final b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    late var b = x != null;
+    // We don't promote based on the initializers of late locals anyhow, because
+    // we don't know when they execute.
+    if (b) x.expectStaticType<Exactly<int?>>();
+  }
+  {
+    late var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    final b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+  {
+    var b;
+    b = x != null;
+    if (b) x.expectStaticType<Exactly<int>>();
+  }
+}
+
+main() {
+  parameterUnmodified(null);
+  parameterUnmodified(0);
+  parameterModifiedLater(null, null);
+  parameterModifiedLater(null, 0);
+  localVariableInitialized(null);
+  localVariableInitialized(0);
+  localVariableModifiedLater(null);
+  localVariableModifiedLater(0);
+}
diff --git a/tools/VERSION b/tools/VERSION
index d534593..15b6cef 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 64
+PRERELEASE 65
 PRERELEASE_PATCH 0
\ No newline at end of file